Sparse matrix are compressed by rows. In a distributed environment, the distribution follows the row distributor
.
This class supports the standard linear algebra. Adding or subtracting two matrices simply writes a+b
and a-b
, respectively. Multiplying a matrix by a scalar writes lambda*a
and the matrix-matrix product also writes a*b
. Matrix-vector product expresses a*x
where x
is a vector described by the vec
class.
template<class T>
class csr<
T,sequential> :
public smart_pointer<csr_rep<T,sequential> > {
public:
typedef csr_rep<T,sequential> rep;
typedef smart_pointer<rep> base;
typedef typename rep::iterator iterator;
typedef typename rep::const_iterator const_iterator;
typedef typename rep::data_iterator data_iterator;
typedef typename rep::const_data_iterator const_data_iterator;
csr() : base(new_macro(rep())) {}
template<class A>
explicit csr(
const asr<T,sequential,A>&
a) : base(new_macro(rep(
a))) {}
{ base::data().resize(loc_nrow1, loc_ncol1, loc_nnz1); }
void resize (
const distributor& row_ownership,
const distributor& col_ownership,
size_type nnz1 = 0)
{ base::data().resize(row_ownership, col_ownership, nnz1); }
csr (const std::initializer_list<details::csr_concat_value<T,sequential> >& init_list);
csr (const std::initializer_list<details::csr_concat_line<T,sequential> >& init_list);
const distributor& row_ownership() const { return base::data().row_ownership(); }
const distributor& col_ownership() const { return base::data().col_ownership(); }
size_type dis_nrow ()
const {
return row_ownership().dis_size(); }
size_type dis_ncol ()
const {
return col_ownership().dis_size(); }
size_type dis_nnz ()
const {
return base::data().nnz(); }
bool is_symmetric() const { return base::data().is_symmetric(); }
void set_symmetry (bool is_symm) const { base::data().set_symmetry(is_symm); }
{ base::data().set_symmetry_by_check(); }
bool is_definite_positive() const { return base::data().is_definite_positive(); }
void set_definite_positive (bool is_defpos) const { base::data().set_definite_positive(is_defpos); }
size_type pattern_dimension()
const {
return base::data().pattern_dimension(); }
void set_pattern_dimension(
size_type dim)
const { base::data().set_pattern_dimension(
dim); }
T max_abs ()
const {
return base::data().max_abs(); }
size_type nrow ()
const {
return base::data().nrow(); }
size_type ncol ()
const {
return base::data().ncol(); }
size_type nnz ()
const {
return base::data().nnz(); }
size_type row_first_index ()
const {
return base::data().row_first_index(); }
size_type row_last_index ()
const {
return base::data().row_last_index(); }
size_type col_first_index ()
const {
return base::data().col_first_index(); }
size_type col_last_index ()
const {
return base::data().col_last_index(); }
const_iterator begin() const { return base::data().begin(); }
const_iterator end() const { return base::data().end(); }
iterator begin_nonconst() { return base::data().begin(); }
iterator end_nonconst() { return base::data().end(); }
const_iterator ext_begin() const { return const_iterator(); }
const_iterator ext_end() const { return const_iterator(); }
iterator ext_begin_nonconst() { return iterator(); }
iterator ext_end_nonconst() { return iterator(); }
int constraint_process_rank() const;
void mult (const vec<element_type,sequential>& x, vec<element_type,sequential>& y) const {
base::data().mult (x,y);
}
vec<element_type,sequential>
operator* (
const vec<element_type,sequential>& x)
const {
vec<element_type,sequential> y (row_ownership(),
element_type());
mult (x, y);
return y;
}
void trans_mult (const vec<element_type,sequential>& x, vec<element_type,sequential>& y) const {
base::data().trans_mult (x,y);
}
vec<element_type,sequential> trans_mult (const vec<element_type,sequential>& x) const {
vec<element_type,sequential> y (col_ownership(),
element_type());
trans_mult (x, y);
return y;
}
csr<T,sequential>
operator+ (
const csr<T,sequential>&
b)
const;
csr<T,sequential>
operator- (
const csr<T,sequential>&
b)
const;
csr<T,sequential>
operator* (
const csr<T,sequential>&
b)
const;
base::data().operator*= (
lambda);
return *this;
}
void dump (
const std::string&
name)
const { base::data().dump(
name); }
};