/[escript]/trunk/paso/src/SparseMatrix.h
ViewVC logotype

Diff of /trunk/paso/src/SparseMatrix.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 4828 by caltinay, Tue Apr 1 03:50:23 2014 UTC revision 4829 by caltinay, Thu Apr 3 04:02:53 2014 UTC
# Line 17  Line 17 
17    
18  /****************************************************************************/  /****************************************************************************/
19    
20  /*   Paso: SparseMatrix and SystemVector */  /*   Paso: SparseMatrix */
21    
22  /****************************************************************************/  /****************************************************************************/
23    
# Line 25  Line 25 
25    
26  /****************************************************************************/  /****************************************************************************/
27    
28  #ifndef INC_PASO_SPARSEMATRIX  #ifndef __PASO_SPARSEMATRIX_H__
29  #define INC_PASO_SPARSEMATRIX  #define __PASO_SPARSEMATRIX_H__
30    
 #include "Common.h"  
31  #include "Pattern.h"  #include "Pattern.h"
 #include "Options.h"  
 #include "Paso.h"  
   
 /****************************************************************************/  
32    
33  namespace paso {  namespace paso {
34    
35    struct SparseMatrix;
36    typedef boost::shared_ptr<SparseMatrix> SparseMatrix_ptr;
37    typedef boost::shared_ptr<const SparseMatrix> const_SparseMatrix_ptr;
38    
39  typedef int SparseMatrixType;  typedef int SparseMatrixType;
40    
41  // this struct holds a stiffness matrix  // this struct holds a sparse matrix
42  struct SparseMatrix {  struct SparseMatrix : boost::enable_shared_from_this<SparseMatrix>
43      SparseMatrixType type;  {
44      dim_t reference_counter;      SparseMatrix(SparseMatrixType type, Pattern_ptr pattern,
45                     dim_t rowBlockSize, dim_t colBlockSize,
46                     bool patternIsUnrolled);
47    
48      dim_t row_block_size;      ~SparseMatrix();
     dim_t col_block_size;  
     dim_t block_size;  
49    
50      dim_t numRows;      void setValues(double value);
     dim_t numCols;  
     Pattern_ptr pattern;  
     dim_t len;  
51    
52      /// this is used for classical CSR or CSC      void copyFromMainDiagonal(double* out) const;
     double *val;  
53    
54      /// package controlling the solver pointer      void copyToMainDiagonal(const double* in);
     index_t solver_package;  
55    
56      /// pointer to data needed by a solver      void copyBlockFromMainDiagonal(double* out) const;
     void* solver_p;  
 };  
57    
58  /*  interfaces: */      void copyBlockToMainDiagonal(const double* in);
59    
60  SparseMatrix* SparseMatrix_alloc(SparseMatrixType type, Pattern_ptr pattern,      void applyBlockMatrix(double* block_diag, int* pivot, double* x,
61                                   dim_t row_block_size, dim_t col_block_size,                            const double* b) const;
                                  bool patternIsUnrolled);  
62    
63  SparseMatrix* SparseMatrix_getReference(SparseMatrix* mat);      void invMain(double* inv_diag, int* pivot) const;
64    
65  dim_t SparseMatrix_getNumColors(const SparseMatrix* mat);      SparseMatrix_ptr unroll(SparseMatrixType type) const;
66        SparseMatrix_ptr getSubmatrix(dim_t n_row_sub,
67                                      dim_t n_col_sub,
68                                      const index_t* row_list,
69                                      const index_t* new_col_index) const;
70    
71  void SparseMatrix_applyDiagonal_CSR_OFFSET0(SparseMatrix* A,      SparseMatrix_ptr getBlock(int blockid) const;
                                             const double* left,  
                                             const double* right);  
72    
73  index_t* SparseMatrix_borrowColoringPointer(const SparseMatrix* mat);      SparseMatrix_ptr getTranspose() const;
74    
75  void SparseMatrix_free(SparseMatrix* mat);      void saveHB_CSC(FILE* handle) const;
76    
77  void SparseMatrix_MatrixVector_CSC_OFFSET0(const double alpha,      void saveMM_CSC(FILE* handle) const;
                                            const SparseMatrix* A,  
                                            const double* in,  
                                            const double beta, double* out);  
78    
79  void SparseMatrix_MatrixVector_CSC_OFFSET1(const double alpha,      void saveMM(const char* filename) const;
                                            const SparseMatrix* A,  
                                            const double* in,  
                                            const double beta, double* out);  
80    
81  void SparseMatrix_MatrixVector_CSR_OFFSET0(const double alpha,      inline index_t* borrowMainDiagonalPointer() const
82                                             const SparseMatrix* A,      {
83                                             const double* in,          return pattern->borrowMainDiagonalPointer();
84                                             const double beta, double* out);      }
85    
86  void SparseMatrix_MatrixVector_CSR_OFFSET1(const double alpha,      inline index_t* borrowColoringPointer() const
87                                             const SparseMatrix* A,      {
88                                             const double* in,         return pattern->borrowColoringPointer();
89                                             const double beta, double* out);      }
90    
91  void SparseMatrix_MatrixVector_CSR_OFFSET0_DIAG(const double alpha,      inline dim_t getNumColors() const
92                                                  const SparseMatrix* A,      {
93                                                  const double* in,         return pattern->getNumColors();
94                                                  const double beta, double* out);      }
95    
96  void SparseMatrix_maxAbsRow_CSR_OFFSET0(const SparseMatrix* A, double* array);      inline dim_t maxDeg() const
97        {
98           return pattern->maxDeg();
99        }
100    
101  void SparseMatrix_addAbsRow_CSR_OFFSET0(const SparseMatrix* A, double* array);      inline dim_t getTotalNumRows() const
102        {
103           return numRows * row_block_size;
104        }
105    
106  void SparseMatrix_addRow_CSR_OFFSET0(const SparseMatrix* A, double* array);      inline dim_t getTotalNumCols() const
107        {
108           return numCols * col_block_size;
109        }
110    
111  void SparseMatrix_nullifyRowsAndCols_CSC_BLK1(SparseMatrix* A,      inline dim_t getNumRows() const
112                                                const double* mask_row,      {
113                                                const double* mask_col,         return numRows;
114                                                double main_diagonal_value);      }
115    
116  void SparseMatrix_nullifyRowsAndCols_CSR_BLK1(SparseMatrix* A,      inline dim_t getNumCols() const
117                                                const double* mask_row,      {
118                                                const double* mask_col,         return numCols;
119                                                double main_diagonal_value);      }
120    
121  void SparseMatrix_nullifyRowsAndCols_CSC(SparseMatrix* A,      inline double getSize() const
122                                           const double* mask_row,      {
123                                           const double* mask_col,          return DBLE(len);
124                                           double main_diagonal_value);      }
125    
126  void SparseMatrix_nullifyRowsAndCols_CSR(SparseMatrix* A,      inline double getSparsity() const
127                                           const double* mask_row,      {
128                                           const double* mask_col,          return getSize()/(DBLE(getTotalNumRows())*DBLE(getTotalNumCols()));
129                                           double main_diagonal_value);      }
130    
131  void SparseMatrix_nullifyRows_CSR_BLK1(SparseMatrix* A, const double* mask_row,      static SparseMatrix_ptr loadMM_toCSR(const char* filename);
                                        double main_diagonal_value);  
132    
 void SparseMatrix_nullifyRows_CSR(SparseMatrix* A, const double* mask_row,  
                                   double main_diagonal_value);  
133    
134  SparseMatrix* SparseMatrix_getSubmatrix(const SparseMatrix* A, dim_t n_row_sub,      void nullifyRowsAndCols_CSC_BLK1(const double* mask_row,
135                                          dim_t n_col_sub,                                       const double* mask_col,
136                                          const index_t* row_list,                                       double main_diagonal_value);
                                         const index_t* new_col_index);  
137    
138  SparseMatrix* SparseMatrix_getBlock(const SparseMatrix* A, int blockid);      void nullifyRowsAndCols_CSR_BLK1(const double* mask_row,
139                                         const double* mask_col,
140                                         double main_diagonal_value);
141    
142  SparseMatrix* SparseMatrix_MatrixMatrix(const SparseMatrix* A,      void nullifyRowsAndCols_CSC(const double* mask_row, const double* mask_col,
143                                          const SparseMatrix* B);                                  double main_diagonal_value);
144    
145  SparseMatrix* SparseMatrix_MatrixMatrixTranspose(const SparseMatrix* A,      void nullifyRowsAndCols_CSR(const double* mask_row, const double* mask_col,
146                                                   const SparseMatrix* B,                                  double main_diagonal_value);
                                                  const SparseMatrix* T);  
147    
148  SparseMatrix* SparseMatrix_unroll(SparseMatrixType type, const SparseMatrix* A);      void nullifyRows_CSR_BLK1(const double* mask_row,
149                                  double main_diagonal_value);
150    
151  SparseMatrix* SparseMatrix_getTranspose(const SparseMatrix* A);      void nullifyRows_CSR(const double* mask_row, double main_diagonal_value);
152    
153  void SparseMatrix_setValues(SparseMatrix* A, double value);      void maxAbsRow_CSR_OFFSET0(double* array) const;
154    
155  void SparseMatrix_saveHB_CSC(const SparseMatrix* A, FILE* handle);      void addAbsRow_CSR_OFFSET0(double* array) const;
156    
157  void SparseMatrix_saveMM_CSC(const SparseMatrix* A, FILE* handle);      void addRow_CSR_OFFSET0(double* array) const;
158    
159  SparseMatrix* SparseMatrix_loadMM_toCSR(const char* fileName);      void applyDiagonal_CSR_OFFSET0(const double* left, const double* right);
160    
161  void SparseMatrix_saveMM(const SparseMatrix* A, const char* fileName);      SparseMatrixType type;
162        dim_t row_block_size;
163        dim_t col_block_size;
164        dim_t block_size;
165        dim_t numRows;
166        dim_t numCols;
167        Pattern_ptr pattern;
168        dim_t len;
169    
170  index_t* SparseMatrix_borrowMainDiagonalPointer(const SparseMatrix* A);      /// this is used for classical CSR or CSC
171        double *val;
172    
173  void SparseMatrix_copyFromMainDiagonal(const SparseMatrix* A, double* out);      /// package controlling the solver pointer
174        index_t solver_package;
175    
176  void SparseMatrix_copyToMainDiagonal(SparseMatrix* A, const double* in);      /// pointer to data needed by a solver
177        void* solver_p;
178    };
179    
180  void SparseMatrix_copyBlockFromMainDiagonal(const SparseMatrix* A, double* out);  //  interfaces:
181    
182  void SparseMatrix_copyBlockToMainDiagonal(SparseMatrix* A, const double* in);  void SparseMatrix_MatrixVector_CSC_OFFSET0(const double alpha,
183                                               const_SparseMatrix_ptr A,
184                                               const double* in,
185                                               const double beta, double* out);
186    
187    void SparseMatrix_MatrixVector_CSC_OFFSET1(const double alpha,
188                                               const_SparseMatrix_ptr A,
189                                               const double* in,
190                                               const double beta, double* out);
191    
192    void SparseMatrix_MatrixVector_CSR_OFFSET0(const double alpha,
193                                               const_SparseMatrix_ptr A,
194                                               const double* in,
195                                               const double beta, double* out);
196    
197    void SparseMatrix_MatrixVector_CSR_OFFSET1(const double alpha,
198                                               const_SparseMatrix_ptr A,
199                                               const double* in,
200                                               const double beta, double* out);
201    
202  void SparseMatrix_applyBlockMatrix(const SparseMatrix* A,  void SparseMatrix_MatrixVector_CSR_OFFSET0_DIAG(const double alpha,
203                                     double* block_diag, int* pivot,                                                  const_SparseMatrix_ptr A,
204                                     double* x, const double* b);                                                  const double* in,
205                                                    const double beta, double* out);
206    
207  void SparseMatrix_invMain(const SparseMatrix* A, double* inv_diag,  SparseMatrix_ptr SparseMatrix_MatrixMatrix(const_SparseMatrix_ptr A,
208                            int* pivot);                                             const_SparseMatrix_ptr B);
209    
210  dim_t SparseMatrix_maxDeg(const SparseMatrix* A);  SparseMatrix_ptr SparseMatrix_MatrixMatrixTranspose(const_SparseMatrix_ptr A,
211  dim_t SparseMatrix_getTotalNumRows(const SparseMatrix* A);                                                      const_SparseMatrix_ptr B,
212  dim_t SparseMatrix_getTotalNumCols(const SparseMatrix* A);                                                      const_SparseMatrix_ptr T);
 dim_t SparseMatrix_getNumRows(const SparseMatrix* A);  
 dim_t SparseMatrix_getNumCols(const SparseMatrix* A);  
 double SparseMatrix_getSize(const SparseMatrix* A);  
 double SparseMatrix_getSparsity(const SparseMatrix* A);  
213    
214  } // namespace paso  } // namespace paso
215    
216  #endif // INC_PASO_SPARSEMATRIX  #endif // __PASO_SPARSEMATRIX_H__
217    

Legend:
Removed from v.4828  
changed lines
  Added in v.4829

  ViewVC Help
Powered by ViewVC 1.1.26