a_mat.cxx

Go to the documentation of this file.

/*
         Copyright 2010-20 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
         */
#include "a_mat.h"
 
// .PORTABILITY : ansi C++
 
//***************************************************************************
//member functions
//-a_mat--------------------------------------------------------------------
a_mat::a_mat(UI i, UI j, double v)
{
        if ((i<1)||(j<1)) throw range_error();
        maxi_ = i;
        maxj_ = j;
        x_ = new std::valarray<double>(v,i*j);
}
//-a_mat--------------------------------------------------------------------
a_mat::a_mat(int i, int j, double v)
{
        if ((i<1)||(j<1)) throw range_error();
        maxi_ = UI(i);
        maxj_ = UI(j);
        x_ = new std::valarray<double>(v,i*j);
}
//-a_mat--------------------------------------------------------------------
a_mat::a_mat(const a_mat& m)
{
        maxi_ = m.maxi();
        maxj_ = m.maxj();
        x_ = new std::valarray<double>(maxi_*maxj_);
        (*x_) = m.x();
}
//-a_mat--------------------------------------------------------------------
a_mat::~a_mat()
{
        delete x_;
}
//-operator=-----------------------------------------------------------------
a_mat & a_mat::operator=(const a_mat& m)
{
        maxi_ = m.maxi();
        maxj_ = m.maxj();
        (*x_) = m.x();
        return (*this);
}
//-operator=-----------------------------------------------------------------
a_mat & a_mat::operator-()
{
        (*x_) = -(*x_);
        return (*this);
}
//-operator==----------------------------------------------------------------
bool a_mat::operator==(const a_mat& a)
{
        if (a.maxi() != maxi_) return false;
        if (a.maxj() != maxj_) return false;
        for (UI i = 0; i < a.size(); i++)
                if (a.x()[i] != (*x_)[i]) return false;
        return true;
}
//-operator+=----------------------------------------------------------------
a_mat & a_mat::operator+=(const a_mat& m)
{
        if (m.maxi() != maxi_) throw compatibility_error();
        if (m.maxj() != maxj_) throw compatibility_error();
        (*x_) += m.x();
        return (*this);
}
//----------------------------------------------------------------
a_mat  a_mat::operator+(const a_mat& m)
{
        a_mat b= *this;
        return b+m;
}
//-operator-=----------------------------------------------------------------
a_mat & a_mat::operator-=(const a_mat& m)
{
        if (m.maxi() != maxi_) throw compatibility_error();
        if (m.maxj() != maxj_) throw compatibility_error();
        (*x_) -= m.x();
        return (*this);
}
//----------------------------------------------------------------
a_mat  a_mat::operator-(const a_mat& m)
{
        a_mat b= *this;
        return b-m;
}
//-operator*=----------------------------------------------------------------
a_mat & a_mat::operator*=(const double v)
{
        (*x_) *= v;
        return (*this);
}
//----------------------------------------------------------------
a_mat  a_mat::operator*(const double v)
{
        a_mat b= *this;
        return v*b;
}
//-operator/=----------------------------------------------------------------
a_mat & a_mat::operator/=(const double v)
{
        (*x_) /= v;
        return (*this);
}
//----------------------------------------------------------------
a_mat  a_mat::operator/(const double v)
{
        a_mat b= *this;
        return (1./v)*b;
}
//-transpose-----------------------------------------------------------------
a_mat a_mat::transpose()
{
        a_mat r(maxj_,maxi_);
        for (UI i = 0; i<maxi_; i++)
        {
                for (UI j = 0; j<maxj_; j++)
                        r(j,i) = (*x_)[i*maxj_+j];
        }
        return r;
}
//-swapc---------------------------------------------------------------------
void a_mat::swapc(UI c1, UI c2)
{
        double v;
        for (UI i = 0; i<maxi_; i++)
        {
                v= (*x_)[i*maxj_+c1];
                (*x_)[i*maxj_+c1] = (*x_)[i*maxj_+c2];
                (*x_)[i*maxj_+c2] = v;
        }
}
//-swapr---------------------------------------------------------------------
void a_mat::swapr(UI r1, UI r2)
{
        double v;
        int rr1 = r1*maxj_;
        int rr2 = r2*maxj_;
        for (UI j = 0; j<maxj_; j++)
        {
                v= (*x_)[rr1+j];
                (*x_)[rr1+j] = (*x_)[rr2+j];
                (*x_)[rr2+j] = v;
        }
}
//-sub_matrix----------------------------------------------------------------
a_mat a_mat::sub_matrix(const UI i0, const UI j0) const
{
        if ((i0>maxi_-1)||(j0>maxj_-1)) throw range_error();
        if ((maxi_<2)||(maxj_<2)) throw compatibility_error();
        a_mat N(maxi_-1,maxj_-1);
        int ni = -1;
        for (UI i = 0; i<maxi_; i++)
        {
                if (i != i0)
                {
                        ni += 1;
                        double nj = -1;
                        for (UI j = 0; j<maxj_; j++)
                        {
                                if (j != j0)
                                {
                                        nj += 1;
                                        N(ni,nj) = (*this)(i,j);
                                }
                        }
                }
        }
        return N;
}
//***************************************************************************
//-operator>>----------------------------------------------------------------
std::istream& operator>> (std::istream& i, UI& v)
{
        int v2;
        i >> v2;
        v = UI(v2);
        return i;
}
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const UI& v)
{
        int v2 = int(v);
        o << v2;
        return o;
}
//-operator<<----------------------------------------------------------------
/*std::ostream& operator<< (std::ostream& o, UI v)
        {
        int v2 = int(v);
        o << v2;
        return o;
        }*/
//-operator>>----------------------------------------------------------------
//---------------------------------------------------------------------------
void a_mat::read(std::istream &in)
{
        int i0,j0;
        in >> i0;
        in >> j0;
        if ((i0 != maxi_)||(j0 != maxj_)) throw a_mat::range_error();
        for (UI j=0; j < maxi_; j++)
        {
                for (UI k=0; k < maxj_; k++)
                        in >> this->operator()(j,k);
        }
}
//---------------------------------------------------------------------------
void a_mat::write(std::ostream &o) const
{
        o << (int)maxi_ << " " << (int)maxj_ << std::endl;
        for (UI i=0; i<maxi_; i++)
        {
                for (UI j=0; j<maxj_; j++)
                        o << this->operator()(i,j) << " ";
                o << std::endl;
        }
}
/*
         std::istream& operator>> (std::istream& i, a_mat & m)
         {
         int i0,j0;
         i >> i0;
         i >> j0;
         if ((i0 != m.maxi_)||(j0 != m.maxj_)) throw a_mat::range_error();
         for (UI j=0; j < m.maxi_; j++)
         {
         for (UI k=0; k < m.maxj_; k++)
         i >> m(j,k);
         }
         return i;
         }
//-operator<<----------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const a_mat & m)
{
o << (int)m.maxi() << " " << (int)m.maxj() << std::endl;
for (UI i=0; i<m.maxi_; i++)
{
for (UI j=0; j<m.maxj_; j++)
o << m(i,j) << " ";
o << std::endl;
}
return o;
}
*/
//***************************************************************************
//-operator+-----------------------------------------------------------------
a_mat operator+(a_mat & a, a_mat & b)
{
        a_mat r = a;
        return r += b;
}
//-operator------------------------------------------------------------------
a_mat operator-(a_mat & a, a_mat & b)
{
        a_mat r = a;
        return r -= b;
}
//-operator*-----------------------------------------------------------------
a_mat operator*(a_mat & a, a_mat & b)
{
        if (a.maxj() != b.maxi()) throw a_mat::compatibility_error();
        a_mat r(a.maxi(),b.maxj());
        double v;
        for (UI i = 0; i < a.maxi(); i++)
        {
                for (UI j = 0; j < b.maxj(); j++)
                {
                        v = 0;
                        for (UI k = 0; k < a.maxj(); k++)
                                v += a(i,k)*b(k,j);
                        r(i,j) = v;
                }
        }
        return r;
}
//-operator*-----------------------------------------------------------------
a_mat operator*(a_mat & a, const double v)
{
        a_mat r = a;
        return r *= v;
}
//-operator*-----------------------------------------------------------------
a_mat operator*(const double v, a_mat & a)
{
        a_mat r = a;
        return r *= v;
}
//-operator/-----------------------------------------------------------------
a_mat operator/(a_mat & a, const double v)
{
        a_mat r = a;
        return r /= v;
}