| 
|   | matrix (const char *_name) | 
|   | 
|   | matrix (const matrix &m) | 
|   | 
| 
void  | saveToFile (const std::string &filename) | 
|   | 
| 
void  | saveToFile (std::ofstream &f) | 
|   | 
| 
bool  | loadFromFile (const std::string &filename) | 
|   | 
| 
bool  | loadFromFile (std::ifstream &f) | 
|   | 
| matrix &  | operator= (const matrix &m) | 
|   | 
| void  | cleanup () | 
|   | 
| void  | zero () | 
|   | 
| void  | ident () | 
|   | 
| Complex  | trace () | 
|   | 
| void  | clear (Complex value) | 
|   | 
| bool  | create (int _r, int _c, Complex *_elements) | 
|   | 
| bool  | create (int _r, int _c) | 
|   | 
| bool  | create (int _r) | 
|   | 
| Complex &  | operator() (int row, int col) | 
|   | 
| void  | random_unitary (const std::vector< double > &phi_v, const std::vector< double > &psi_v, const std::vector< double > &chi_v, double alpha) | 
|   | 
| bool  | eigenValues (std::vector< double > &values) | 
|   | 
| double  | safeLog (double x) | 
|   | 
| double  | entropy () | 
|   | 
| Complex  | getDirect (int row, int col) | 
|   | 
| void  | setDirect (int _n, Complex data) | 
|   | 
| void  | setDirect (int row, int col, Complex data) | 
|   | 
| void  | setDirect (int row, int col, double re, double im) | 
|   | 
| Complex  | get (int _n) | 
|   | 
| Complex *  | getElements () | 
|   | 
| void  | print (std::ostream &f, bool printAll=false) | 
|   | 
| void  | multiplyScalar (Complex &c) | 
|   | 
| void  | sqTranspose () | 
|   | 
| void  | transpose (matrix &B) | 
|   | 
| void  | subtract (Complex &c) | 
|   | 
| void  | subtract (matrix *B, matrix *output) | 
|   | 
| void  | add (matrix *B, matrix *output) | 
|   | 
| 
void  | random (double smallValue, double largeValue) | 
|   | 
| void  | add (matrix *B) | 
|   | 
| 
void  | dot (matrix *B, Complex &output) | 
|   | 
| bool  | multiply (matrix &B, matrix &output, char TRANSB='N') | 
|   | 
| void  | tensor (matrix *B, matrix *output) | 
|   | 
| int  | getRows () | 
|   | 
| int  | getCols () | 
|   | 
| int  | getSize () | 
|   | 
Definition at line 92 of file Algebra.h.
 
◆ matrix() [1/3]
  
  
      
        
          | algebra::matrix::matrix  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ matrix() [2/3]
  
  
      
        
          | algebra::matrix::matrix  | 
          ( | 
          const char *  | 
          _name | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ matrix() [3/3]
  
  
      
        
          | algebra::matrix::matrix  | 
          ( | 
          const matrix &  | 
          m | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ ~matrix()
  
  
      
        
          | algebra::matrix::~matrix  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ add() [1/2]
  
  
      
        
          | void algebra::matrix::add  | 
          ( | 
          matrix *  | 
          B | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ add() [2/2]
◆ cleanup()
  
  
      
        
          | void algebra::matrix::cleanup  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ clear()
  
  
      
        
          | void algebra::matrix::clear  | 
          ( | 
          Complex  | 
          value | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ create() [1/3]
  
  
      
        
          | bool algebra::matrix::create  | 
          ( | 
          int  | 
          _r | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ create() [2/3]
  
  
      
        
          | bool algebra::matrix::create  | 
          ( | 
          int  | 
          _r,  | 
         
        
           | 
           | 
          int  | 
          _c  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ create() [3/3]
  
  
      
        
          | bool algebra::matrix::create  | 
          ( | 
          int  | 
          _r,  | 
         
        
           | 
           | 
          int  | 
          _c,  | 
         
        
           | 
           | 
          Complex *  | 
          _elements  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ eigenValues()
      
        
          | bool algebra::matrix::eigenValues  | 
          ( | 
          std::vector< double > &  | 
          values | ) | 
           | 
        
      
 
 
◆ entropy()
  
  
      
        
          | double algebra::matrix::entropy  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ get()
  
  
      
        
          | Complex algebra::matrix::get  | 
          ( | 
          int  | 
          _n | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getCols()
  
  
      
        
          | int algebra::matrix::getCols  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getDirect()
  
  
      
        
          | Complex algebra::matrix::getDirect  | 
          ( | 
          int  | 
          row,  | 
         
        
           | 
           | 
          int  | 
          col  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ getElements()
  
  
      
        
          | Complex * algebra::matrix::getElements  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getRows()
  
  
      
        
          | int algebra::matrix::getRows  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ getSize()
  
  
      
        
          | int algebra::matrix::getSize  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ ident()
  
  
      
        
          | void algebra::matrix::ident  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ multiply()
      
        
          | bool algebra::matrix::multiply  | 
          ( | 
          matrix &  | 
          B,  | 
        
        
           | 
           | 
          matrix &  | 
          output,  | 
        
        
           | 
           | 
          char  | 
          TRANSB = 'N'  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
◆ multiplyScalar()
  
  
      
        
          | void algebra::matrix::multiplyScalar  | 
          ( | 
          Complex &  | 
          c | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ operator()()
  
  
      
        
          | Complex & algebra::matrix::operator()  | 
          ( | 
          int  | 
          row,  | 
         
        
           | 
           | 
          int  | 
          col  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ operator=()
◆ print()
  
  
      
        
          | void algebra::matrix::print  | 
          ( | 
          std::ostream &  | 
          f,  | 
         
        
           | 
           | 
          bool  | 
          printAll = false  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ random_unitary()
      
        
          | void algebra::mat::random_unitary  | 
          ( | 
          const std::vector< double > &  | 
          phi_v,  | 
        
        
           | 
           | 
          const std::vector< double > &  | 
          psi_v,  | 
        
        
           | 
           | 
          const std::vector< double > &  | 
          chi_v,  | 
        
        
           | 
           | 
          double  | 
          alpha  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
◆ safeLog()
  
  
      
        
          | double algebra::matrix::safeLog  | 
          ( | 
          double  | 
          x | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ setDirect() [1/3]
  
  
      
        
          | void algebra::matrix::setDirect  | 
          ( | 
          int  | 
          _n,  | 
         
        
           | 
           | 
          Complex  | 
          data  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ setDirect() [2/3]
  
  
      
        
          | void algebra::matrix::setDirect  | 
          ( | 
          int  | 
          row,  | 
         
        
           | 
           | 
          int  | 
          col,  | 
         
        
           | 
           | 
          Complex  | 
          data  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ setDirect() [3/3]
  
  
      
        
          | void algebra::matrix::setDirect  | 
          ( | 
          int  | 
          row,  | 
         
        
           | 
           | 
          int  | 
          col,  | 
         
        
           | 
           | 
          double  | 
          re,  | 
         
        
           | 
           | 
          double  | 
          im  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ sqTranspose()
  
  
      
        
          | void algebra::matrix::sqTranspose  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ subtract() [1/2]
  
  
      
        
          | void algebra::matrix::subtract  | 
          ( | 
          Complex &  | 
          c | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ subtract() [2/2]
  
  
      
        
          | void algebra::matrix::subtract  | 
          ( | 
          matrix *  | 
          B,  | 
         
        
           | 
           | 
          matrix *  | 
          output  | 
         
        
           | 
          ) | 
           |  | 
         
       
   | 
  
inline   | 
  
 
 
◆ tensor()
      
        
          | void algebra::matrix::tensor  | 
          ( | 
          matrix *  | 
          B,  | 
        
        
           | 
           | 
          matrix *  | 
          output  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
◆ trace()
  
  
      
        
          | Complex algebra::matrix::trace  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ transpose()
  
  
      
        
          | void algebra::matrix::transpose  | 
          ( | 
          matrix &  | 
          B | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ zero()
  
  
      
        
          | void algebra::matrix::zero  | 
          ( | 
           | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
The documentation for this class was generated from the following files:
- D:/Projekt/ECF_trunk/examples/quantum/Quantum/Algebra.h
 
- D:/Projekt/ECF_trunk/examples/quantum/Quantum/Algebra.cpp