DD-AVX_d_spmat.hpp

Go to the documentation of this file.

#ifndef DD_MATRIX_HPP
#define DD_MATRIX_HPP
 
class d_real_vector;
class dd_real_vector;
struct dd_real;
 
class d_real_SpMat{
    public:
        int row=0;
        int nnz=0;
        std::vector<double> val;
        std::vector<int> row_ptr;
        std::vector<int> col_ind;
 
        d_real_SpMat(){}
 
        d_real_SpMat(int r, int c){
            if(r != c){
                std::cerr << "error, r!=c, square matrix only now" << std::endl;
                assert(1);
            }
            row=r;
            nnz = 0;
            val.resize(nnz, 0.0);
            row_ptr.resize(row+1, 0);
            col_ind.resize(nnz, 0);
        }
 
        d_real_SpMat(int r, int c, int NNZ){
            if(r != c){
                std::cerr << "error, r!=c, square matrix only now" << std::endl;
                assert(1);
            }
            row=r;
            nnz=NNZ;
            val.resize(nnz, 0.0);
            row_ptr.resize(row+1, 0);
            col_ind.resize(nnz, 0);
        }
 
        d_real_SpMat(int r, int c, int NNZ, int* row_pointer, int* col_index, double* value){
            if(r != c){
                std::cerr << "error, r!=c, square matrix only now" << std::endl;
                assert(1);
            }
            row=r;
            nnz=NNZ;
 
            row_ptr.resize(row+1, 0);
            for(int i=0; i<row+1; i++){
                row_ptr[i] = row_pointer[i];
            }
 
            val.resize(nnz, 0.0);
            col_ind.resize(nnz, 0);
            for(int i=0; i<nnz; i++){
                val[i] = value[i];
                col_ind[i] = col_index[i];
            }
        }
 
        d_real_SpMat(std::vector<int>& row_pointer, std::vector<int>& col_index, std::vector<double>& value){
 
            row_ptr.resize(row_pointer.size());
            for(int i=0; i<row_ptr.size()+1; i++){
                row_ptr[i] = row_pointer[i];
            }
 
            val.resize(value.size());
            col_ind.resize(col_index.size());
            for(int i=0; i<val.size(); i++){
                val[i] = value[i];
                col_ind[i] = col_index[i];
            }
        }
        
        d_real_SpMat(int r, std::vector<int>& row_index, std::vector<int>& col_index, std::vector<double>& value){
 
            row_ptr.resize(r+1);
 
            int c_row = 0;
            row_ptr[0] = 0;
            for (int i = 0; i < row_index.size(); i++) {
                int idx = row_index[0];
 
                if(c_row == idx){
                    row_ptr[c_row+1] = i+1;
                }
                else{
                    c_row = c_row + 1;
                    row_ptr[c_row+1] = i+1;
                }
            }
 
            val.resize(value.size());
            col_ind.resize(col_index.size());
            for(int i=0; i<val.size(); i++){
                val[i] = value[i];
                col_ind[i] = col_index[i];
            }
        }
 
//--allocate, free---------------------------------------
        void clear(){
            row = 0;
            nnz = 0;
            val.clear();
            row_ptr.clear();
            col_ind.clear();
        }
 
//--I/O---------------------------------------
        void input_mm(const char* filename);
 
        void output_mm(const char* filename);
 
        void output();
 
//--get---------------------------------------
        int get_row() const{return row;};
 
        int get_nnz() const{return nnz;};
 
        double at(const int r, const int c);
 
        void insert(const int r, const int c, const double a);
 
        d_real_vector get_row_vec(const int r);
 
        d_real_vector get_col_vec(const int c);
 
        d_real_vector get_diag_vec();
 
        std::vector<double>::reference data() {
            return val[0];
        }
 
 
// //--copy---------------------------------------
        void copy(const d_real_SpMat& mat);
 
        d_real_SpMat& operator=(const d_real_SpMat& mat);
};
 
#endif