matrix.h

Go to the documentation of this file.

#ifndef __MATRIX_H__
#define __MATRIX_H__

namespace CTF {
    //template<typename dtype>
    //class Vector : public Tensor<dtype>;

  template<typename dtype=double> 
  class Matrix : public Tensor<dtype> {
    public:
      int nrow, ncol, symm;
      Matrix();


      Matrix(Matrix<dtype> const & A);


      Matrix(Tensor<dtype> const & A);

      Matrix(int                       nrow,
             int                       ncol,
             World &                   wrld,
             CTF_int::algstrct const & sr=Ring<dtype>(),
             char const *              name=NULL,
             int                       profile=0);

      Matrix(int                       nrow,
             int                       ncol,
             World &                   wrld,
             char const *              name,
             int                       profile=0,
             CTF_int::algstrct const & sr=Ring<dtype>());



      Matrix(int                       nrow,
             int                       ncol,
             int                       atr=0,
             World &                   wrld=get_universe(),
             CTF_int::algstrct const & sr=Ring<dtype>(),
             char const *              name=NULL,
             int                       profile=0);

      Matrix(int                       nrow,
             int                       ncol,
             int                       atr,
             World &                   wrld,
             char const *              name,
             int                       profile=0,
             CTF_int::algstrct const & sr=Ring<dtype>());



      Matrix(int                       nrow,
             int                       ncol,
             char const *              idx,
             Idx_Partition const &     prl,
             Idx_Partition const &     blk=Idx_Partition(),
             int                       atr=0,
             World &                   wrld=get_universe(),
             CTF_int::algstrct const & sr=Ring<dtype>(),
             char const *              name=NULL,
             int                       profile=0);

      void write_mat(int           mb,
                     int           nb,
                     int           pr,
                     int           pc,
                     int           rsrc,
                     int           csrc,
                     int           lda,
                     dtype const * data);


 
      Matrix(int                       nrow,
             int                       ncol,
             int                       mb,
             int                       nb,
             int                       pr,
             int                       pc,
             int                       rsrc,
             int                       csrc,
             int                       lda,
             dtype const *             data,
             World &                   wrld=get_universe(),
             CTF_int::algstrct const & sr=Ring<dtype>(),
             char const *              name=NULL,
             int                       profile=0);
     

      Matrix(int const *               desc,
             dtype const *             data,
             World &                   wrld=get_universe(),
             CTF_int::algstrct const & sr=Ring<dtype>(),
             char const *              name=NULL,
             int                       profile=0);

      void read_mat(int     mb,
                    int     nb,
                    int     pr,
                    int     pc,
                    int     rsrc,
                    int     csrc,
                    int     lda,
                    dtype * data);

  
      void get_desc(int & ictxt, int *& desc);


      void read_mat(int const * desc,
                    dtype *     data);

      /*
       * \brief prints matrix by row and column (modify print(...) overload in set.h if you would like a different print format)
       */
      void print_matrix();

      /*
       * \calculates the reduced QR decomposition, A = Q x R for A of dimensions m by n with m>=n
       * \param[out] Q m-by-n matrix with orthonormal columns
       * \param[out] R n-by-n upper-triangular matrix
       */
      void qr(Matrix<dtype> & Q, Matrix<dtype> & R);

      /*
       * \calculates the singular value decomposition, M = U x S x VT, of matrix using pdgesvd from ScaLAPACK
       * \param[out] U left singular vectors of matrix
       * \param[out] S singular values of matrix
       * \param[out] VT right singular vectors of matrix
       * \param[in] rank rank of output matrices. If rank = 0, will use min(matrix.rows, matrix.columns)
       */
      void svd(Matrix<dtype> & U, Vector<dtype> & S, Matrix<dtype> & VT, int rank = 0);

  };
}
#include "matrix.cxx"
#endif