MATH_MaskMatrix.h

Go to the documentation of this file.

#ifndef MATH_MaskMatrix_H
#define MATH_MaskMatrix_H

#include "MATH_Matrix.h"

#include "CORE_Array.h"

#include "MATH_MaskVector.h"


DEFINE_SPTR(MATH_MaskMatrix);

class MATH_MaskMatrix : public  MATH_Matrix {
    SP_OBJECT(MATH_MaskMatrix);

private:

    
  
    
protected:
    MATH_MaskMatrix(void) {
      
    }
    
    
    
    // DESTRUCTORS 
    
  
    virtual ~MATH_MaskMatrix(void) {
    }

public:
  


    //SET Methods
    //===========

   
    
    
    //GET Methods
    //===========
    
  
    //arithmetic methods
    //==================
  
public:
    
    virtual void product(const tReal& alpha,const MATH_Vector& x,const tReal& beta, MATH_Vector& y) const {
        if (beta==0) {
            product(alpha,x,y);
            return;
        }
        
        if (alpha==0) {
            y.dot(beta);
            return;
        }
        //verify the size of X
        tUIndex nX=x.getSize();
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "MATH_MaskMatrix::product(beta,X,alpha,Y)",
                                 "error in dimension of vector X "+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
        
        //verify the size  of B = size of X
        tUIndex nY=y.getSize();
        if (nY!=getRowsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "MATH_MaskMatrix::product(beta,X,alpha,Y)",
                                 "error in dimension of vector Y "+CORE_Integer::toString(nY)+" != "+
                                 CORE_Integer::toString(getRowsNumber()));
        
        //get the increment 1 by default except for mask vector X
        tUCInt incx=1;
        tUIndex sx=0;
        const MATH_MaskVector* mv=dynamic_cast<const MATH_MaskVector*>(&x);
        if (mv!=null) {
            incx=mv->getIncrement();
            sx=mv->getStartIndex();
        }
        //get the increment 1 by default except for mask vector Y
        tUCInt incy=1;
        tUIndex sy=0;
        mv=dynamic_cast<const MATH_MaskVector*>(&y);
        if (mv!=null) {
            incy=mv->getIncrement();
            sy=mv->getStartIndex();
        }
        const tReal *x0=&x[sx];
        tReal *y0=&y[sy];
        if (x0==y0) {
            throw CORE_Exception("emicrom/math/solver",
                                "MATH_MaskMatrix::product(beta,X,alpha,Y)",
                                "Y pointer must be different from X pointer is not a real field");
        }
        
        //compute the product
        product(nX,alpha,incx,x0,beta,incy,y0);
    }
    
    virtual void product(const tReal& alpha,const MATH_Vector& x,MATH_Vector& y) const {
    
        //pathological cases
        if (alpha==0) {
            y.setSize(getRowsNumber());
            y.init(0);
            return;
        }
        
        if (alpha==1) {
            product(x,y);
            return;
        }

        //set the size of y
        y.setSize(getRowsNumber());
        
        //verify the size of X
        tUIndex nX=x.getSize();
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "MATH_MaskMatrix::product(beta,X,Y)",
                                 "error in dimension of vector X: "+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
        
        //get the increment 1 by default except for mask vector X
        tUCInt incx=1;
        tUIndex sx=0;
        const MATH_MaskVector* mv=dynamic_cast<const MATH_MaskVector*>(&x);
        if (mv!=null) {
            incx=mv->getIncrement();
            sx=mv->getStartIndex();
        }
        //get the increment 1 by default except for mask vector Y
        tUCInt incy=1;
        tUIndex sy=0;
        mv=dynamic_cast<const MATH_MaskVector*>(&y);
        if (mv!=null) {
            incy=mv->getIncrement();
            sy=mv->getStartIndex();
        }

        const tReal *x0=&x[sx];
        tReal *y0=&y[sy];
        if (x0==y0) {
            throw CORE_Exception("emicrom/math/solver",
                                 "MATH_MaskMatrix::product(alpha,X,Y)",
                                 "Y pointer must be different from X pointer is not a real field");
        }
        //compute the product
        product(nX,alpha,incx,x0,0.,incy,y0);
        
    }

    virtual void product(const MATH_Vector& x,MATH_Vector& y) const {
        //verify the size of X
        tUIndex nX=x.getSize();
        if (nX!=getColumnsNumber())
            throw CORE_Exception("emicrom/math/solver",
                                 "MATH_MaskMatrix::product(X,Y)",
                                 "error in dimension of vector X "+CORE_Integer::toString(nX)+" != "+
                                 CORE_Integer::toString(getColumnsNumber()));
        //set the size of y
        y.setSize(getRowsNumber());
        
        //get the increment 1 by default except for mask vector X
        tUCInt incx=1;
        tUIndex sx=0;
        const MATH_MaskVector* mv=dynamic_cast<const MATH_MaskVector*>(&x);
        if (mv!=null) {
            incx=mv->getIncrement();
            sx=mv->getStartIndex();
        }
        //get the increment 1 by default except for mask vector Y
        tUCInt incy=1;
        tUIndex sy=0;
        mv=dynamic_cast<const MATH_MaskVector*>(&y);
        if (mv!=null) {
            incy=mv->getIncrement();
            sy=mv->getStartIndex();
        }
        const tReal *x0=&x[sx];
        tReal *y0=&y[sy];
        if (x0==y0) {
            throw CORE_Exception("emicrom/math/solver",
                                "MATH_MaskMatrix::product(X,Y)",
                                "Y pointer must be different from X pointer is not a real field");
        }
        //compute the product
        product(nX,1.,incx,x0,0.,incy,y0);
        
    }
protected:
    virtual void product(const tUIndex& n,
                         const tReal& alpha,
                         const tUSInt& incX,
                         const tReal* x,
                         const tReal& beta,
                         const tUSInt& incY,tReal* y) const=0;


    
};
#endif