Matrix.hpp

/*
 * Matrix.hpp
 * 
 * Copyright 2011 Fernando Pujaico Rivera <fernando.pujaico.rivera@gmail.com>
 * 
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 * 
 */
 
#ifndef __PDS_MATRIX_HPP__
#define __PDS_MATRIX_HPP__
 
 
#include <string>
#include <list>
#include <vector>
#include <Pds/Size>
#include <Pds/RaDefines>
#include <Pds/RegionRect>
#include <Pds/Array>
 
#include <iostream>
#include <fstream>
 
namespace Pds{
 
class Vector;
 
class Matrix
{
private:
    double **array;
    unsigned int nlin;
    unsigned int ncol;
    
    friend class CMatrix; 
    friend class Vector; 
    friend class Array<double>;
    friend class Array<unsigned int>;
    friend class Array<unsigned char>;
public:
 
    Matrix(void);
    
    Matrix(unsigned int N);
    
    Matrix(const Pds::Size &S);
 
    Matrix(const Pds::Matrix &B);
    
 
    template <class Datum>
    Matrix(const Pds::Array<Datum> &B);
 
 
    Matrix(const char *str);
    
    
    Matrix(unsigned int Nlin,unsigned int Ncol);
    
    Matrix(unsigned int Nlin,unsigned int Ncol,double val);
    
    Matrix(double (*func)(double),const Pds::Matrix &B );
    
    Matrix(double (*func)(double,double),const Pds::Matrix &B , double var);
 
    
    Matrix(double (*func)(double,double),const Pds::Matrix &B ,const Pds::Matrix &C);
 
    
    Matrix(double (*func)(double,double,double),const Pds::Matrix &B ,const Pds::Matrix &C, double var);
    
    Matrix(double (*func)(double,double,double),
            const Pds::Matrix &X, 
            const Pds::Matrix &Y, 
            const Pds::Matrix &Z);
 
    Matrix(double (*func)(double,double,double,double),
            const Pds::Matrix &X, 
            const Pds::Matrix &Y, 
            const Pds::Matrix &Z,
            double var);
 
    Matrix(double (*func)(double,double,double,double),
            const Pds::Matrix &X, 
            const Pds::Matrix &Y, 
            const Pds::Matrix &Z,
            const Pds::Matrix &W);
 
    Matrix(Pds::Ra::FormatType Type,std::string filepath);
    
    ~Matrix(); 
    
public:
 
    bool IsEmpty(void) const;
 
    bool IsNotEmpty(void) const;
 
 
    bool IsSimilarTo(const Pds::Matrix &B) const;
 
    bool IsNotSimilarTo(const Pds::Matrix &B) const;
    
    bool IsMulBy(const Pds::Matrix &B) const;
 
    bool IsNotMulBy(const Pds::Matrix &B) const;
 
    bool IsInRange(unsigned int lin,unsigned int col) const;
    
    bool IsNotInRange(unsigned int lin,unsigned int col) const;
    
    bool IsInSizeRange(double lin,double col) const;
    
 
    bool IsRowMatrix(void) const;
 
 
    bool IsColMatrix(void) const;
 
    bool IsZero(void) const;
 
    bool IsLeq(double val) const;
 
    bool IsLeq(const Pds::Matrix &B) const;
 
    bool IsGeq(double val) const;
    
    bool IsGeq(const Pds::Matrix &B) const;
 
    bool IsEqualTo(double val) const;
    
    bool IsEqualTo(const Pds::Matrix &B) const;
 
    bool HasInf(void) const;
    
    bool HasNan(void) const;
    
 
    bool HasNotFinite(void) const;
 
 
public:
 
    bool FillRandC(double p1);
    
    bool FillRandN(void);
 
    bool FillRandN(double U, double Sigma);
    
    bool FillRandU(void);
 
    bool FillRandU(int a, int b);
    
    bool FillRandU(double a, double b);
    
    bool FillId(void );
 
    bool Fill(double val);
 
    bool FillLinSpace(double a,double b);
public:
 
    unsigned int Nlin(void) const;
    
    unsigned int Ncol(void) const;
    
    unsigned int Nel(void) const;
    
    Pds::Size Size(void) const;
    
    unsigned int LinEnd(void) const;
    
    unsigned int ColEnd(void) const;
    
    unsigned int End(void) const;
 
 
public:
 
    double Get(unsigned int id) const;
    
    double Get(unsigned int lin,unsigned int col) const;
    
 
    const double &GetRaw(unsigned int lin,unsigned int col) const
    {
        return this->array[lin][col];
    }
 
 
    void SetRaw(unsigned int lin,unsigned int col,const double &val)
    {
        this->array[lin][col]=val;
    }
 
    bool Set(unsigned int id,double val);
    
    bool Set(unsigned int lin,unsigned int col,double val);
    
    double &At(unsigned int lin,unsigned int col);
 
    double &At(unsigned int id);
    
    
    double Bilinear(double lin,double col) const;
    
public:
 
    Pds::Vector GetDiagonal(void) const;
    
    bool SetDiagonal(const Pds::Vector V);
 
 
    Pds::Matrix GetMatrix(unsigned int lin_init,unsigned int col_init,unsigned int lin_end,unsigned int col_end) const;
    
    Pds::Matrix GetMatrix(unsigned int lin_init,unsigned int col_init,Pds::Size size) const;
    
    bool SetMatrix(unsigned int lin,unsigned int col,const Pds::Matrix &B);
 
    
    Pds::Matrix GetRow(unsigned int lin) const;
    
    Pds::Matrix GetCol(unsigned int col) const;
    
    Pds::Matrix GetRows(unsigned int lin_init,unsigned int lin_end) const;
    
    Pds::Matrix GetCols(unsigned int col_init,unsigned int col_end) const;
    
    Pds::Matrix GetRows(std::list<unsigned int> List) const;
    
    Pds::Matrix GetCols(std::list<unsigned int> List) const;
    
    Pds::Matrix GetRows(std::vector<unsigned int> Vec) const;
    
    Pds::Matrix GetCols(std::vector<unsigned int> Vec) const;
 
    
    Pds::Matrix GetRowsRand(unsigned int N) const;
    
    Pds::Matrix GetColsRand(unsigned int N) const;
    
    bool SetRowValue(unsigned int lin,double value);
    
    bool SetRowVector(unsigned int lin,const Pds::Vector &X);   
    
    bool SetColValue(unsigned int col,double value);
    
    Pds::Vector GetRowAsColVector(unsigned int lin) const;
 
    
    Pds::Vector GetColVector(unsigned int col) const;
    
    bool SetColVector(unsigned int col,const Pds::Vector V);
    
    bool SetColVector(unsigned int col,double (*func)(double),const Pds::Vector V);
    
    bool SetColVector(unsigned int col,double (*func)(double,double),const Pds::Vector V,double var);
 
public:
 
    bool RowAddAssig(unsigned int lin1,unsigned int lin2,double alpha);
    
    bool RowMulAssig(unsigned int lin,double alpha);
    
    bool RowDivAssig(unsigned int lin,double alpha);
    
    bool RowSwap(unsigned int lin1,unsigned int lin2);
    
    int RowSwapBelow(unsigned int n);
    
    bool RowReduction(void);
public:
 
    double Sum(void) const;
      
    double Mean(void) const;
    
    double Var(double *mean=NULL) const;
    
    double Std(double *mean=NULL) const;
 
    
    double MaxAbs(unsigned int *id=NULL) const;
    
    double MinAbs(unsigned int *id=NULL) const;
    
    double Max(unsigned int *id=NULL) const;
    
    double Min(unsigned int *id=NULL) const;
    
    Pds::Matrix MinInCols(std::vector<unsigned int> &Lin) const;
    
    Pds::Matrix MinInCols(Pds::Array<unsigned int> &Lin) const;
 
    double R2(const Pds::Matrix &Y) const;
 
    double Rf(const Pds::Matrix &Y) const;
    
    double Mape(const Pds::Matrix &B) const;
public:
 
    double Corr(const Pds::Matrix &B) const;
    
    Pds::Matrix XCorr(const Pds::Matrix &B, bool Same=false) const;
 
    Pds::Matrix FilterMean3(void) const;
 
 
    Pds::Matrix FilterMean3b(void) const;
 
    Pds::Matrix Resize(double factor) const;
 
public:
 
    double Det(void) const;
    
    double Dot(const Pds::Matrix &B) const;
   
    double Rms(void) const;
 
 
    double MeanAbsolute(void) const;
 
    double MeanSquare(void) const;
 
    double SumSquare(void) const;
 
    double Norm(void) const;
 
    
    double PNorm1(void) const;
 
    
    double PNormInf(void) const;
 
    Pds::Vector Multiindex(const Pds::Vector &d) const;
public:
 
    std::vector<unsigned int> Find(void) const;
 
    Pds::Matrix FindRows(const Pds::Vector &B) const;
 
    Pds::Matrix FindRows(const Pds::Vector &B,double b) const;
 
public:
 
    bool Apply( double (*func)(double) );
 
    bool Apply( double (*func)(double), Pds::Matrix &B);
    
    bool Apply( double (*func)(double,double), double var);
 
    bool ApplyInCol(unsigned int col, double (*func)(double) );
 
    bool ApplyInCol(unsigned int col, double (*func)(double,double), double var);
 
 
public:
 
    Pds::Matrix OperateRows(double (*func)(const Pds::Matrix &Row)) const;
 
    Pds::Matrix OperateCols(double (*func)(const Pds::Matrix &Col)) const;
 
 
    Pds::Matrix Scale(double minval,double maxval) const;
 
    Pds::Matrix Round(unsigned int decimal=0) const;
public:
 
    bool CopyRegion(const Pds::RegionRect &Rin,const Pds::RegionRect &Rout,Pds::Matrix &Mout) const;
 
    bool InitRegion(Pds::RegionRect R,double val);
 
    Pds::RegionRect GetRegion(void) const;
 
    bool MeanOfRegion(const Pds::RegionRect &Rin, double *mean) const;
 
    double MeanOfRegion(const Pds::RegionRect &Rin) const;
 
    bool MeanSquareOfRegion(const Pds::RegionRect &Rin, double *mean) const;
 
    double MeanSquareOfRegion(const Pds::RegionRect &Rin) const;
 
    bool StdAndMeanOfRegion(const Pds::RegionRect &Rin, double *std, double *mean) const;
 
 
    bool CorrNormRegions(   const Pds::Matrix &M1,
                            const Pds::RegionRect &R0,
                            const Pds::RegionRect &R1, 
                            double *corrn) const;
 
    bool CorrNormRegions(   const Pds::Matrix &M1,
                            const Pds::RegionRect &R0,
                            const Pds::RegionRect &R1, 
                            double means0,
                            double means1,
                            double *corrn) const;
 
    bool CorrPearsonRegions(const Pds::Matrix &M1,
                            const Pds::RegionRect &R0,
                            const Pds::RegionRect &R1, 
                            double *pcc) const;
 
    bool CorrPearsonRegions(   const Pds::Matrix &M1,
                        const Pds::RegionRect &R0,
                        const Pds::RegionRect &R1,
                        double mean0,
                        double mean1,
                        double std0,
                        double std1,
                        double *pcc) const;
public:
 
    std::string ToString(void) const;
 
 
    void Print(std::string str) const;
 
    void Print(void) const;
 
public:
 
    void MakeEmpty(void);
 
    bool Reshape(unsigned int Nlin,unsigned int Ncol);
 
 
    bool FusionVer(std::list<Pds::Matrix> &list);
 
 
public:
 
    bool SaveInStream(std::ofstream &myfile) const;
    
    bool LoadFromStream(std::ifstream &ifs,unsigned int Nlin,unsigned int Ncol);
    
    bool Save(const char* filepath) const;
 
    bool Load(const char* filepath);
    
    bool ExportCsvFile(const char* filepath,char delimitador=',') const;
    
    
    bool ExportMatFile(const char* pname,const char* filepath) const;
 
    bool ExportBmpFile(const unsigned char colormap[256][3],const std::string &filepath) const;
public:
 
    static Pds::Matrix GetSamples(const std::vector<Pds::Matrix> &Block);
    
    static Pds::Matrix GetSamples(const std::vector<Pds::Matrix> &Block,const std::vector<unsigned int> Id);
 
    static Pds::Matrix FromString(const std::string &str);
 
    static bool ExportBmpFile(  const Pds::Matrix &R,
                                const Pds::Matrix &G,
                                const Pds::Matrix &B,
                                const std::string &bmpfilename);
 
    static std::vector<Pds::Matrix>  ImportBmpFile( const std::string &bmpfilename);
 
    static Pds::Matrix MeanBlock( const std::vector<Pds::Matrix> &Block);
public:
 
    Pds::Matrix T(void) const;
    
    Pds::Matrix MtM(void) const;
    
    
    Pds::Matrix Inv(double *rcond=NULL) const;
    
    Pds::Matrix PInv(double *rcond=NULL) const;
    
    
    Pds::Matrix operator -(void) const;
    
    Pds::Matrix Minus(void) const;
    
    Pds::Matrix operator +(void) const;
    
    Pds::Matrix Plus(void) const;
    Pds::Matrix operator * (double b) const;
    
    Pds::Matrix operator * (const Pds::Matrix &B) const;
    
    Pds::Matrix Mul(double b) const;
    
    Pds::Matrix Mul(const Pds::Matrix &B) const;
    
    Pds::Matrix Mul(const Pds::Vector &B) const;
   
    Pds::Matrix MulComp(double b,const Pds::Vector &B) const;
    
    bool MulComp(double b,const Pds::Vector &B, Pds::Vector &Out) const;
        
    Pds::Matrix MulT(const Pds::Matrix &B) const;
        
    Pds::Matrix TMul(const Pds::Matrix &B) const;
    
    
    Pds::Matrix operator + (double b) const;
    
    Pds::Matrix operator + (const Pds::Matrix &B) const;
    
    Pds::Matrix Add(double b) const;
    
    Pds::Matrix Add(const Pds::Matrix &B) const;
    
    
    Pds::Matrix operator - (double b) const;
    
    Pds::Matrix operator -(const Pds::Matrix &B) const;
    
    Pds::Matrix Sub(double b) const;
    
    Pds::Matrix Sub(const Pds::Matrix &B) const;
    
 
    Pds::Matrix AddRowMatrix(const Pds::Matrix &B) const;
    
    Pds::Matrix SubRowMatrix(const Pds::Matrix &B) const;
 
    Pds::Matrix operator / (double b) const;
 
 
    Pds::Matrix operator/(const Pds::Matrix &B) const;
 
    Pds::Matrix Div(double b) const;
 
    Pds::Matrix Div(const Pds::Matrix &B) const;  
 
 
    Pds::Matrix DivSelf(double b) const;
 
    Pds::Matrix operator&(const Pds::Matrix &B) const;
 
    Pds::Matrix Product(const Pds::Matrix &B) const;
 
    Pds::Matrix Product(double (*func)(double),const Pds::Matrix &B) const;
 
    bool ProductSelf(const Pds::Matrix &B);
    
    bool ProductSelf(double (*func)(double),const Pds::Matrix &B);
 
    bool ProductSelfMinus(double b, const Pds::Matrix &B);
    
 
    bool ProductSelfMinus(const Pds::Matrix &B,double b);
 
    bool ProductSelfPlus(double b, const Pds::Matrix &B);
    
    Pds::Matrix Pow(const Pds::Matrix &B) const;
 
 
    Pds::Matrix Pow(double val) const;
 
    Pds::Matrix Geq(double b) const;
    
    Pds::Matrix Geq(Pds::Matrix B) const;
    
    Pds::Matrix Leq(double b) const;
    
    Pds::Matrix Leq(const Pds::Matrix &B) const;
    
 
    Pds::Matrix EqualTo(double b) const;
    
    Pds::Matrix EqualTo(const Pds::Matrix &B) const;
 
    Pds::Matrix NotEqualTo(double b) const;
    
    Pds::Matrix NotEqualTo(const Pds::Matrix &B) const;
 
    
    Pds::Matrix EqualToInf(void) const;
    
    Pds::Matrix EqualToNan(void) const;
    
    Pds::Matrix EqualToFinite(void) const;
 
    Pds::Matrix& operator -=(double b);
    
    Pds::Matrix& operator -=(const Pds::Matrix &B);
    
    bool SubAssig(double b);
    
    bool SubAssig(const Pds::Matrix &B);
    
    Pds::Matrix& operator +=(double b);
    
    Pds::Matrix& operator +=(const Pds::Matrix &B);
    
    bool AddAssig(double b);
 
    bool AddAssig(const Pds::Matrix &B);
 
    bool AddAssig(double alpha, const Pds::Matrix &B);
 
    bool AddAssig(double alpha, const Pds::Matrix &B, double beta, const Pds::Matrix &C);
    
    bool AddAssigAt(unsigned int lin,unsigned int col,const Pds::Matrix &B);
    
    Pds::Matrix& operator *=(double b);
    
    Pds::Matrix& operator *=(const Pds::Matrix &B);
    
    bool MulAssig(double b);
    
    bool MulAssig(const Pds::Matrix &B);
    
    
    
    Pds::Matrix& operator = (const Pds::Matrix &B);
    
    bool Copy(const Pds::Matrix &B);
    
    
    
    Pds::Matrix& operator = (double val);
    
    bool Copy(double val);
 
    template <class Datum>
    Pds::Matrix& operator = (const Pds::Array<Datum> &B);
 
    template <class Datum>
    bool Copy(const Pds::Array<Datum> &B);
 
 
    Pds::Matrix MultipleMse(const Pds::Matrix &B) const;
 
    Pds::Matrix MultipleMse(const std::vector<Pds::Matrix> &Block) const;
 
    Pds::Array<unsigned int> IdInMultipleMse(const Pds::Matrix &B) const;
 
    Pds::Array<unsigned int> IdInMultipleMse(const std::vector<Pds::Matrix> &Block) const;
 
 
public:
 
    static double** ArrayAllocate(double (*func)(double),const Pds::Matrix &A);
 
    static double** ArrayAllocate(double (*func)(double,double),const Pds::Matrix &A,double var);
 
    static double** ArrayAllocate(double (*func)(double,double),const Pds::Matrix &A,const Pds::Matrix &B);
 
    static double** ArrayAllocate(double (*func)(double,double,double),const Pds::Matrix &A,const Pds::Matrix &B,double var);
    
    static double** ArrayAllocate(double (*func)(double,double,double),
                                    const Pds::Matrix &A,
                                    const Pds::Matrix &B,
                                    const Pds::Matrix &C);
    
    static double** ArrayAllocate(double (*func)(double,double,double,double),
                                    const Pds::Matrix &A,
                                    const Pds::Matrix &B,
                                    const Pds::Matrix &C,
                                    double var);
    
    static double** ArrayAllocate(double (*func)(double,double,double,double),
                                    const Pds::Matrix &A,
                                    const Pds::Matrix &B,
                                    const Pds::Matrix &C,
                                    const Pds::Matrix &D);
 
};// class Matrix
 
} // namespace Pds
 
 
 
 
std::ostream& operator<<(std::ostream &out,const Pds::Matrix &mat);
 
Pds::Matrix operator+(double b,const Pds::Matrix &A);
 
Pds::Matrix operator-(double b,const Pds::Matrix &A);
 
Pds::Matrix operator*(double b,const Pds::Matrix &A);
 
Pds::Matrix operator/(double b,const Pds::Matrix &A);
 
#endif