Loading...
Searching...
No Matches
<tt>csr</tt>

distributed compressed sparse matrix

# Description

Sparse matrix are compressed by rows. In a distributed environment, the distribution follows the row `distributor`.

# Algebra

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.

By extension, `trans(a)` returns the transpose. Multiplying a vector by the transpose matrix writes `a.trans_mult(x)` and do not requires to build the transpose matrix.

# Implementation

This documentation has been generated from file linalg/lib/csr.h

The `csr` class is a template class with both the floating type and the memory model as parameters. Here is the interface for the `sequential` memory model. The `distributed` case presents a similar interface.

template<class T>
class csr<T,sequential> : public smart_pointer<csr_rep<T,sequential> > {
public:
// typedefs:
typedef csr_rep<T,sequential> rep;
typedef smart_pointer<rep> base;
typedef typename rep::memory_type memory_type;
typedef typename rep::size_type size_type;
typedef typename rep::element_type element_type;
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;
// allocators/deallocators:
csr() : base(new_macro(rep())) {}
template<class A>
explicit csr(const asr<T,sequential,A>& a) : base(new_macro(rep(a))) {}
void resize (size_type loc_nrow1 = 0, size_type loc_ncol1 = 0, size_type loc_nnz1 = 0)
{ 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); }
// allocators from initializer list
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);
// accessors:
// global sizes
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(); }
size_type dis_ext_nnz () const { return 0; }
bool is_symmetric() const { return base::data().is_symmetric(); }
void set_symmetry (bool is_symm) const { base::data().set_symmetry(is_symm); }
void set_symmetry_by_check (const T& tol = std::numeric_limits<T>::epsilon()) const
{ 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(); }
// local sizes
size_type nrow () const { return base::data().nrow(); }
size_type ncol () const { return base::data().ncol(); }
size_type nnz () const { return base::data().nnz(); }
// range on local memory
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(); }
// accessors, only for distributed (for interface compatibility)
size_type ext_nnz() const { return 0; }
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(); }
size_type jext2dis_j (size_type jext) const { return 0; }
int constraint_process_rank() const;
// algebra:
// y := a*x
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;
}
// a+b, a-b, a*b
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;
// lambda*a
csr<T,sequential>& operator*= (const T& lambda) {
base::data().operator*= (lambda);
return *this;
}
// output:
void dump (const std::string& name) const { base::data().dump(name); }
};
size_type
field::size_type size_type
Definition branch.cc:430
rheolef::csr::memory_type
M memory_type
Definition csr.h:319
T
Expr1::float_type T
Definition field_expr.h:230
dump
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format format format format format format format format format format format format format format format format format dump
Definition iorheo-members.h:119
rheolef::details::max_abs
T max_abs(const T &x)
Definition keller_details.h:47
rheolef::operator-
csr< T, sequential > operator-(const csr< T, sequential > &a)
Definition csr.h:447
rheolef::operator*=
std::enable_if< details::is_rheolef_arithmetic< U >::value, ad3_basic< T > & >::type operator*=(ad3_basic< T > &a, const U &b)
Definition ad3.h:367
rheolef::operator+
std::enable_if< details::is_rheolef_arithmetic< U >::value, ad3_basic< T > >::type operator+(const U &a, const ad3_basic< T > &b)
Definition ad3.h:222
rheolef::operator*
csr< T, sequential > operator*(const T &lambda, const csr< T, sequential > &a)
Definition csr.h:437
lambda
Definition yield_slip_circle.h:34