marMatrix.cpp

Go to the documentation of this file.

// marMatrix.cpp: implementation of the marMatrix class.
//

#include "marMatrix.h"
#include <assert.h>

// Construction
marMatrix::marMatrix(size_t size1, size_t size2)
        :shallowCopy(false)
{
        _size1=size1;
        _size2=size2;
        _data=new double[_size1*_size2];
}

marMatrix::marMatrix(double *data, size_t size1, size_t size2)
        :shallowCopy(true)
{
        if (size1==0 || size2==0)
        {
                assert(false);
        }
        else
        {
                _size1=size1;
                _size2=size2;
                _data=data;

// PS ->                size_t iMax=_size1*_size2;
// PS ->                _data=new double[iMax];
// PS -> 
// PS ->                for (int i=0;i<iMax;i++)
// PS ->                {
// PS ->                        _data[i]=data[i];
// PS ->                }

        }
}


marMatrix::marMatrix(const marMatrix &m)
        :shallowCopy(false)
{
        if (m._size1==0 || m._size2==0)
        {
                assert(false);
        }
        else
        {
                _size1=m._size1;
                _size2=m._size2;

                size_t iMax=_size1*_size2;
                _data=new double[iMax];

                int i;
                for (i=0;i<iMax;i++)
                {
                        _data[i]=m._data[i];
                }
        }
}

// Destruction
marMatrix::~marMatrix()
{
        if (!shallowCopy) 
        {
                delete _data;
        }
        else
        {
                _data=NULL;
        }
}

// Opérateurs
// ---------------------------------------------------------------------
/*Affichage*/
std::ostream& operator<<(std::ostream& os,const marMatrix& m)
{
        int i,j;
        for (i =0;i<m._size1;i++)
        {
                for (j =0;j<m._size2;j++)
                {
                        os << " " << m._data[i*m._size2+j];
                }
                os << "\n";
        }
    return(os);
}

// ---------------------------------------------------------------------
/*Casting*/
marMatrix::operator double*() const 
{ 
        return(_data);
}

// ---------------------------------------------------------------------
/*Indexation*/
double& marMatrix::operator()(size_t i, size_t j) 
{ 
        return(_data[i*_size2+j]);
}

const double& marMatrix::operator()(size_t i, size_t j) const
{
        return(_data[i*_size2+j]);
}

// ---------------------------------------------------------------------
/*Affectation*/
marMatrix& marMatrix::operator=(const marMatrix& o)
{
        _size1=o._size1;
        _size2=o._size2;
        if (!(_data==NULL)&&(!shallowCopy))
        {
                delete _data;
        }
        shallowCopy=false;
        size_t iMax=_size1*_size2;
        _data=new double[iMax];

        int i;
        for (i=0;i<iMax;i++)
        {
                _data[i]=o._data[i];
        }
        return (*this);
}

marMatrix& marMatrix::operator=(double o)
{
        if (_size1!=0 && _size2!=0)
        {
                if (!(_data==NULL)&&(!shallowCopy))
                {
                        delete _data;
                }
                shallowCopy=false;
                size_t iMax=_size1*_size2;
                _data=new double[iMax];
                for (int i=0;i<iMax;i++)
                {
                        _data[i]=o;
                }
        }
        else
        {
                assert(false);
        }
        return (*this);
}

marMatrix& marMatrix::operator=(double*o)
{
        if (_size1!=0 && _size2!=0)
        {
                if (!(_data==NULL)&&(!shallowCopy))
                {
                        delete _data;
                }
                shallowCopy=false;
                size_t iMax=_size1*_size2;
                _data=new double[iMax];
                for (int i=0;i<iMax;i++)
                {
                        _data[i]=o[i];
                }
        }
        else
        {
                assert(false);
        }
        return (*this);
}

// ---------------------------------------------------------------------
/*Comparaison*/
bool marMatrix::operator==(const marMatrix& o) const
{
    bool equal=true;
        
    if(_size1!=o._size1 || _size2!=o._size2)
        {
                return(false);
        }
        size_t iMax=_size1*_size2;

        for (int i=0;i<iMax && equal;i++)
        {
                equal=equal && (_data[i]==o._data[i]); 
        }
    return(equal);
}

bool marMatrix::operator!=(const marMatrix& o) const
{
        return(!((*this)==o));
}

// ---------------------------------------------------------------------
/*Addition*/
marMatrix marMatrix::operator+(const marMatrix& o)
{
        marMatrix result(*this);
        
        if ((o._size1!=result._size1) 
                || (result._size1==0) 
                || (o._size2!=result._size2) 
                || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0 ; i < iMax ; i++)
                {
                        result._data[i]+=o._data[i];
                }
        }
        return result;
}

marMatrix marMatrix::operator+(double o)
{
        marMatrix result(*this);
        
        if ((result._size1==0) || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0;i < iMax;i++)
                {
                        result._data[i]+=o;
                }
        }
        return result;
}

marMatrix marMatrix::operator+(double*o)
{
        marMatrix result(*this);
        
        if ((result._size1==0) || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0;i < iMax;i++)
                {
                        result._data[i]+=o[i];
                }
        }
        return result;
}

// ---------------------------------------------------------------------
/*Soustraction*/
marMatrix marMatrix::operator-(const marMatrix& o)
{
        marMatrix result(*this);
        
        if ((o._size1!=result._size1) 
                || (result._size1==0) 
                || (o._size2!=result._size2) 
                || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0;i < iMax;i++)
                {
                        result._data[i]-=o._data[i];
                }
        }
        return result;
}

marMatrix marMatrix::operator-(double o)
{
        marMatrix result(*this);
        
        if ((result._size1==0) || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0;i < iMax;i++)
                {
                        result._data[i]-=o;
                }
        }
        return result;
}

marMatrix marMatrix::operator-(double*o)
{
        marMatrix result(*this);
        
        if ((result._size1==0) || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0;i < iMax;i++)
                {
                        result._data[i]-=o[i];
                }
        }
        return result;
}

// ---------------------------------------------------------------------
/*Multiplication (produit scalaire)*/
marMatrix marMatrix::operator*(double o)
{
        marMatrix result(*this);
        
        if ((result._size1==0) || (result._size2==0))
        {
                assert(false);
        }
        else 
        {
                size_t iMax=result._size1*result._size2;
                int i;
                for (i=0;i < iMax;i++)
                {
                        result._data[i]*=o;
                }
        }
        return result;
}

marMatrix marMatrix::operator*(const marMatrix &o)
{
        size_t mA=_size1;
        size_t nA=_size2;
        size_t mB=o._size1;
        size_t nB=o._size2;
        size_t mR=mA;
        size_t nR=nB;

        marMatrix result(mR,nR);
        result=0.0;

        int k,i,j;
        if (nA==mB)
        {
                for (k=0;k<nA;k++)
                {
                        for (i=0;i<mR;i++)
                        {
                                for (j=0;j<nR;j++)
                                {
                                        result(i,j)+=(*this)(i,k)*o(k,j);
                                }
                        }
                }
        }
        else
        {
                assert(false);
        }
        return result;
}

marVector marMatrix::operator*(const marVector &o)
{
        marVector result(_size1);
        if (o.size()!=_size2)
        {
                assert(false);
        }
        else
        {
                marMatrix resultM(_size1,1);
                marMatrix B((double*)o,o.size(),1);
                resultM=(*this)*B;
                result=(double*)resultM;
        }
        return result;
}

// Méthodes
size_t marMatrix::rows() const
{
    return _size1; 
}

size_t marMatrix::columns() const
{
        return _size2;
}