>;
│ │ │ │ │ +280 public:
│ │ │ │ │ +_2_8_5 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_2_9_0 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_2_9_2 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_2_9_7 typedef C _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e;
│ │ │ │ │ +298
│ │ │ │ │ +_3_0_6 _B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r (P& p, const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& c)
│ │ │ │ │ +307 : _preconditioner(stackobject_to_shared_ptr(p)), _communication(c)
│ │ │ │ │ +308 { }
│ │ │ │ │ +309
│ │ │ │ │ +_3_1_7 _B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r (const std::shared_ptr& p, const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e&
│ │ │ │ │ +c)
│ │ │ │ │ +318 : _preconditioner(p), _communication(c)
│ │ │ │ │ +319 { }
│ │ │ │ │ +320
│ │ │ │ │ +_3_2_6 virtual void _p_r_e (X& x, Y& b)
│ │ │ │ │ +327 {
│ │ │ │ │ +328 _communication.copyOwnerToAll(x,x); // make dirichlet values consistent
│ │ │ │ │ +329 _preconditioner->pre(x,b);
│ │ │ │ │ +330 }
│ │ │ │ │ +331
│ │ │ │ │ +_3_3_7 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +338 {
│ │ │ │ │ +339 _preconditioner->apply(v,d);
│ │ │ │ │ +340 _communication.copyOwnerToAll(v,v);
│ │ │ │ │ +341 }
│ │ │ │ │ +342
│ │ │ │ │ +343 template
│ │ │ │ │ +_3_4_4 void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +345 {
│ │ │ │ │ +346 _preconditioner->template apply(v,d);
│ │ │ │ │ +347 _communication.copyOwnerToAll(v,v);
│ │ │ │ │ +348 }
│ │ │ │ │ +349
│ │ │ │ │ +_3_5_5 virtual void _p_o_s_t (X& x)
│ │ │ │ │ +356 {
│ │ │ │ │ +357 _preconditioner->post(x);
│ │ │ │ │ +358 }
│ │ │ │ │ +359
│ │ │ │ │ +_3_6_1 virtual _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y _c_a_t_e_g_o_r_y() const
│ │ │ │ │ +362 {
│ │ │ │ │ +363 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_o_v_e_r_l_a_p_p_i_n_g;
│ │ │ │ │ +364 }
│ │ │ │ │ +365
│ │ │ │ │ +366 private:
│ │ │ │ │ +368 std::shared_ptr _preconditioner;
│ │ │ │ │ +369
│ │ │ │ │ +371 const _c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e& _communication;
│ │ │ │ │ +372 };
│ │ │ │ │ +373
│ │ │ │ │ +376} // end namespace
│ │ │ │ │ +377
│ │ │ │ │ +378#endif
│ │ │ │ │ +_g_s_e_t_c_._h_h
│ │ │ │ │ +Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ +generic way.
│ │ │ │ │ +_i_o_._h_h
│ │ │ │ │ +Some generic functions for pretty printing vectors and matrices.
│ │ │ │ │ +_p_r_e_c_o_n_d_i_t_i_o_n_e_r_s_._h_h
│ │ │ │ │ +Define general preconditioner interface.
│ │ │ │ │ +_s_c_a_l_a_r_p_r_o_d_u_c_t_s_._h_h
│ │ │ │ │ +Define base class for scalar product and norm.
│ │ │ │ │ +_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ +Implementation of the BCRSMatrix class.
│ │ │ │ │ +_s_o_l_v_e_r_s_._h_h
│ │ │ │ │ +Implementations of the inverse operator interface.
│ │ │ │ │ +_i_l_u_._h_h
│ │ │ │ │ +The incomplete LU factorization kernels.
│ │ │ │ │ +_o_p_e_r_a_t_o_r_s_._h_h
│ │ │ │ │ +Define general, extensible interface for operators. The available
│ │ │ │ │ +implementation wraps a matrix.
│ │ │ │ │ +_v_b_v_e_c_t_o_r_._h_h
│ │ │ │ │ +???
│ │ │ │ │ +_o_w_n_e_r_o_v_e_r_l_a_p_c_o_p_y_._h_h
│ │ │ │ │ +Classes providing communication interfaces for overlapping Schwarz methods.
│ │ │ │ │ _b_v_e_c_t_o_r_._h_h
│ │ │ │ │ This file implements a vector space as a tensor product of a given vector
│ │ │ │ │ space. The number of compon...
│ │ │ │ │ -_m_a_t_r_i_x_u_t_i_l_s_._h_h
│ │ │ │ │ -Some handy generic functions for ISTL matrices.
│ │ │ │ │ -_c_o_l
│ │ │ │ │ -Col col
│ │ │ │ │ -DDeeffiinniittiioonn matrixmatrix.hh:351
│ │ │ │ │ +_D_u_n_e_:_:_b_s_o_r_b
│ │ │ │ │ +void bsorb(const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ +SSOR step.
│ │ │ │ │ +DDeeffiinniittiioonn gsetc.hh:646
│ │ │ │ │ +_D_u_n_e_:_:_b_s_o_r_f
│ │ │ │ │ +void bsorf(const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ +SOR step.
│ │ │ │ │ +DDeeffiinniittiioonn gsetc.hh:634
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_g_e_t
│ │ │ │ │ -PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::
│ │ │ │ │ -VertexProperties, EP, VM, EM > >::Type get(const Amg::VertexVisitedTag &tag,
│ │ │ │ │ -Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
│ │ │ │ │ -DDeeffiinniittiioonn dependency.hh:293
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n
│ │ │ │ │ -DDeeffiinniittiioonn matrixutils.hh:211
│ │ │ │ │ -_D_u_n_e_:_:_C_o_m_p_r_e_s_s_i_o_n_S_t_a_t_i_s_t_i_c_s
│ │ │ │ │ -Statistics about compression achieved in implicit mode.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:88
│ │ │ │ │ -_D_u_n_e_:_:_C_o_m_p_r_e_s_s_i_o_n_S_t_a_t_i_s_t_i_c_s_:_:_o_v_e_r_f_l_o_w___t_o_t_a_l
│ │ │ │ │ -size_type overflow_total
│ │ │ │ │ -total number of elements written to the overflow area during construction.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:94
│ │ │ │ │ -_D_u_n_e_:_:_C_o_m_p_r_e_s_s_i_o_n_S_t_a_t_i_s_t_i_c_s_:_:_m_a_x_i_m_u_m
│ │ │ │ │ -size_type maximum
│ │ │ │ │ -maximum number of non-zeroes per row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:92
│ │ │ │ │ -_D_u_n_e_:_:_C_o_m_p_r_e_s_s_i_o_n_S_t_a_t_i_s_t_i_c_s_:_:_a_v_g
│ │ │ │ │ -double avg
│ │ │ │ │ -average number of non-zeroes per row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:90
│ │ │ │ │ -_D_u_n_e_:_:_C_o_m_p_r_e_s_s_i_o_n_S_t_a_t_i_s_t_i_c_s_:_:_m_e_m___r_a_t_i_o
│ │ │ │ │ -double mem_ratio
│ │ │ │ │ -fraction of wasted memory resulting from non-used overflow area.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:99
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r
│ │ │ │ │ -A wrapper for uniform access to the BCRSMatrix during and after the build stage
│ │ │ │ │ -in implicit build mod...
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:117
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ -Matrix::block_type block_type
│ │ │ │ │ -The block_type of the underlying matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:125
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r
│ │ │ │ │ -ImplicitMatrixBuilder(Matrix &m)
│ │ │ │ │ -Creates an ImplicitMatrixBuilder for matrix m.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:170
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_M_a_t_r_i_x
│ │ │ │ │ -M_ Matrix
│ │ │ │ │ -The underlying matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:122
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r
│ │ │ │ │ -ImplicitMatrixBuilder(Matrix &m, size_type rows, size_type cols, size_type
│ │ │ │ │ -avg_cols_per_row, double overflow_fraction)
│ │ │ │ │ -Sets up matrix m for implicit construction using the given parameters and
│ │ │ │ │ -creates an ImplicitBmatrixu...
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:194
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_M
│ │ │ │ │ -size_type M() const
│ │ │ │ │ -The number of columns in the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:217
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -Matrix::size_type size_type
│ │ │ │ │ -The size_type of the underlying matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:128
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_o_p_e_r_a_t_o_r_[_]
│ │ │ │ │ -row_object operator[](size_type i) const
│ │ │ │ │ -Returns a proxy for entries in row i.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:205
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_N
│ │ │ │ │ -size_type N() const
│ │ │ │ │ -The number of rows in the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:211
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_r_o_w___o_b_j_e_c_t
│ │ │ │ │ -Proxy row object for entry access.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:137
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_a_t_r_i_x_B_u_i_l_d_e_r_:_:_r_o_w___o_b_j_e_c_t_:_:_o_p_e_r_a_t_o_r_[_]
│ │ │ │ │ -block_type & operator[](size_type j) const
│ │ │ │ │ -Returns entry in column j.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:142
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -A sparse block matrix with compressed row storage.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:466
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -typename Imp::BlockTraits< B >::field_type field_type
│ │ │ │ │ -export the type representing the field
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:488
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_o_w_A_l_l_o_c_a_t_o_r__
│ │ │ │ │ -std::allocator_traits< A >::template rebind_alloc< row_type > rowAllocator_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2054
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_x_i_s_t_s
│ │ │ │ │ -bool exists(size_type i, size_type j) const
│ │ │ │ │ -return true if (i,j) is in pattern
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2036
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_u_i_l_d_S_t_a_g_e
│ │ │ │ │ -BuildStage buildStage() const
│ │ │ │ │ -The current build stage of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2022
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_e_g_i_n
│ │ │ │ │ -Iterator begin()
│ │ │ │ │ -Get iterator to first row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:671
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_c_o_p_y_W_i_n_d_o_w_S_t_r_u_c_t_u_r_e
│ │ │ │ │ -void copyWindowStructure(const BCRSMatrix &Mat)
│ │ │ │ │ -Copy the window structure from another matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2151
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_t_r_y
│ │ │ │ │ -B & entry(size_type row, size_type col)
│ │ │ │ │ -Returns reference to entry (row,col) of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1317
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_m_m_h_v
│ │ │ │ │ -void mmhv(const X &x, Y &y) const
│ │ │ │ │ -y -= A^H x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1841
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_s_m_h_v
│ │ │ │ │ -void usmhv(const field_type &alpha, const X &x, Y &y) const
│ │ │ │ │ -y += alpha A^H x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1864
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_m_t_v
│ │ │ │ │ -void umtv(const X &x, Y &y) const
│ │ │ │ │ -y += A^T x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1751
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_c_o_m_p_r_e_s_s_i_o_n_B_u_f_f_e_r_S_i_z_e__
│ │ │ │ │ -double compressionBufferSize_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2076
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_m
│ │ │ │ │ -size_type m
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2060
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_c_o_n_s_t___i_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator< const row_type > const_iterator
│ │ │ │ │ -The const iterator over the matrix rows.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:703
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_e
│ │ │ │ │ -void allocate(size_type rows, size_type columns, size_type allocationSize, bool
│ │ │ │ │ -allocateRows, bool allocate_data)
│ │ │ │ │ -Allocate memory for the matrix structure.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2235
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_x_p_y
│ │ │ │ │ -BCRSMatrix & axpy(field_type alpha, const BCRSMatrix &b)
│ │ │ │ │ -Add the scaled entries of another matrix to this one.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1621
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_i_n_f_i_n_i_t_y___n_o_r_m___r_e_a_l
│ │ │ │ │ -FieldTraits< ft >::real_type infinity_norm_real() const
│ │ │ │ │ -simplified infinity norm (uses Manhattan norm for complex values)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1934
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_~_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -~BCRSMatrix()
│ │ │ │ │ -destructor
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:821
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_e_D_a_t_a
│ │ │ │ │ -void allocateData()
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2276
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_d_e_a_l_l_o_c_a_t_e
│ │ │ │ │ -void deallocate(bool deallocateRows=true)
│ │ │ │ │ -deallocate memory of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2168
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator RowIterator
│ │ │ │ │ -rename the iterators for easier access
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:697
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_[_]
│ │ │ │ │ -row_type & operator[](size_type i)
│ │ │ │ │ -random access to the rows
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:545
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix()
│ │ │ │ │ -an empty matrix
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:745
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_d_r_o_w_s_i_z_e_s
│ │ │ │ │ -void endrowsizes()
│ │ │ │ │ -indicate that size of all rows is defined
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1146
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_i_n_c_r_e_m_e_n_t_r_o_w_s_i_z_e
│ │ │ │ │ -void incrementrowsize(size_type i, size_type s=1)
│ │ │ │ │ -increment size of row i by s (1 by default)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1135
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_m_t_v
│ │ │ │ │ -void mtv(const X &x, Y &y) const
│ │ │ │ │ -y = A^T x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1736
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_m_h_v
│ │ │ │ │ -void umhv(const X &x, Y &y) const
│ │ │ │ │ -y += A^H x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1818
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_n_o_n_z_e_r_o_e_s
│ │ │ │ │ -size_type nonzeroes() const
│ │ │ │ │ -number of blocks that are stored (the number of blocks that possibly are
│ │ │ │ │ -nonzero)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2013
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_i_o_n_S_i_z_e__
│ │ │ │ │ -size_type allocationSize_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2062
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_o_n_s_t_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -ConstIterator ConstRowIterator
│ │ │ │ │ -rename the const row iterator for easier access
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:734
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_e_a_d_y
│ │ │ │ │ -BuildStage ready
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2049
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_I_n_d_i_c_e_s_N_o_S_o_r_t
│ │ │ │ │ -void setIndicesNoSort(size_type row, It begin, It end)
│ │ │ │ │ -Set all column indices for row from the given iterator range.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1232
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_u_i_l_d___m_o_d_e
│ │ │ │ │ -BuildMode build_mode
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2048
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_r_o_w_s_i_z_e
│ │ │ │ │ -void setrowsize(size_type i, size_type s)
│ │ │ │ │ -Set number of indices in row i to s.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1114
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_I_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator< row_type > Iterator
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:668
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_n_n_z__
│ │ │ │ │ -size_type nnz_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2061
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_*_=
│ │ │ │ │ -BCRSMatrix & operator*=(const field_type &k)
│ │ │ │ │ -vector space multiplication with scalar
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1513
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_i_z_e_A_l_l_o_c_a_t_o_r__
│ │ │ │ │ -std::allocator_traits< A >::template rebind_alloc< size_type > sizeAllocator_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2056
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_i_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator< row_type > iterator
│ │ │ │ │ -The iterator over the (mutable matrix rows.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:667
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_s_m_t_v
│ │ │ │ │ -void usmtv(const field_type &alpha, const X &x, Y &y) const
│ │ │ │ │ -y += alpha A^T x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1795
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ -ConstIterator beforeBegin() const
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:728
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_o_n_s_t_I_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator< const row_type > ConstIterator
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:704
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_e_f_o_r_e_B_e_g_i_n
│ │ │ │ │ -Iterator beforeBegin()
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:691
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a
│ │ │ │ │ -B * a
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2069
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_u_i_l_d_M_o_d_e
│ │ │ │ │ -BuildMode
│ │ │ │ │ -we support two modes
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:506
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_i_m_p_l_i_c_i_t
│ │ │ │ │ -@ implicit
│ │ │ │ │ -Build entries randomly with an educated guess for the number of entries per
│ │ │ │ │ -row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:535
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_n_k_n_o_w_n
│ │ │ │ │ -@ unknown
│ │ │ │ │ -Build mode not set!
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:539
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_a_n_d_o_m
│ │ │ │ │ -@ random
│ │ │ │ │ -Build entries randomly.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:526
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_o_w___w_i_s_e
│ │ │ │ │ -@ row_wise
│ │ │ │ │ -Build in a row-wise manner.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:517
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix(size_type _n, size_type _m, size_type _nnz, BuildMode bm)
│ │ │ │ │ -matrix with known number of nonzeroes
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:752
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_o_w___t_y_p_e
│ │ │ │ │ -Imp::CompressedBlockVectorWindow< B, size_type > row_type
│ │ │ │ │ -implement row_type with compressed vector
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:500
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_o_m_p_r_e_s_s_i_o_n_S_t_a_t_i_s_t_i_c_s
│ │ │ │ │ -::Dune::CompressionStatistics< size_type > CompressionStatistics
│ │ │ │ │ -The type for the statistics object returned by compress()
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:503
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_-_=
│ │ │ │ │ -BCRSMatrix & operator-=(const BCRSMatrix &b)
│ │ │ │ │ -Subtract the entries of another matrix from this one.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1596
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix(const BCRSMatrix &Mat)
│ │ │ │ │ -copy constructor
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:802
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_d
│ │ │ │ │ -Iterator end()
│ │ │ │ │ -Get iterator to one beyond last row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:677
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r
│ │ │ │ │ -row_type * r
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2066
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_I_n_d_i_c_e_s
│ │ │ │ │ -void setIndices(size_type row, It begin, It end)
│ │ │ │ │ -Set all column indices for row from the given iterator range.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1255
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_d_d_i_n_d_e_x
│ │ │ │ │ -void addindex(size_type row, size_type col)
│ │ │ │ │ -add index (row,col) to the matrix
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1188
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_O_v_e_r_f_l_o_w_T_y_p_e
│ │ │ │ │ -std::map< std::pair< size_type, size_type >, B > OverflowType
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2078
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_o_l_I_t_e_r_a_t_o_r
│ │ │ │ │ -row_type::Iterator ColIterator
│ │ │ │ │ -Iterator for the entries of each row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:700
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_f_r_o_b_e_n_i_u_s___n_o_r_m
│ │ │ │ │ -FieldTraits< field_type >::real_type frobenius_norm() const
│ │ │ │ │ -frobenius norm: sqrt(sum over squared values of entries)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1906
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -A::size_type size_type
│ │ │ │ │ -The type for the index access and the size.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:497
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_/_=
│ │ │ │ │ -BCRSMatrix & operator/=(const field_type &k)
│ │ │ │ │ -vector space division by scalar
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1541
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_v_e_r_f_l_o_w
│ │ │ │ │ -OverflowType overflow
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2079
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_+_=
│ │ │ │ │ -BCRSMatrix & operator+=(const BCRSMatrix &b)
│ │ │ │ │ -Add the entries of another matrix to this one.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1574
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix(size_type _n, size_type _m, size_type _avg, double
│ │ │ │ │ -compressionBufferSize, BuildMode bm)
│ │ │ │ │ -construct matrix with a known average number of entries per row
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:781
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_c_r_e_a_t_e_e_n_d
│ │ │ │ │ -CreateIterator createend()
│ │ │ │ │ -get create iterator pointing to one after the last block
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1100
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_f_r_o_b_e_n_i_u_s___n_o_r_m_2
│ │ │ │ │ -FieldTraits< field_type >::real_type frobenius_norm2() const
│ │ │ │ │ -square of frobenius norm, need for block recursion
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1889
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ -Iterator beforeEnd()
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:684
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_o_n_s_t_C_o_l_I_t_e_r_a_t_o_r
│ │ │ │ │ -row_type::ConstIterator ConstColIterator
│ │ │ │ │ -Const iterator to the entries of a row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:737
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_s_m_v
│ │ │ │ │ -void usmv(F &&alpha, const X &x, Y &y) const
│ │ │ │ │ -y += alpha A x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1713
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_g_e_t_r_o_w_s_i_z_e
│ │ │ │ │ -size_type getrowsize(size_type i) const
│ │ │ │ │ -get current number of indices in row i
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1125
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_M
│ │ │ │ │ -size_type M() const
│ │ │ │ │ -number of columns (counted in blocks)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2007
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_n
│ │ │ │ │ -size_type n
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2059
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_c_r_e_a_t_e_b_e_g_i_n
│ │ │ │ │ -CreateIterator createbegin()
│ │ │ │ │ -get initial create iterator
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1094
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_u_i_l_d_S_t_a_g_e
│ │ │ │ │ -BuildStage
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:469
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_r_o_w_S_i_z_e_s_B_u_i_l_t
│ │ │ │ │ -@ rowSizesBuilt
│ │ │ │ │ -The row sizes of the matrix are known.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:480
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_u_i_l_t
│ │ │ │ │ -@ built
│ │ │ │ │ -The matrix structure is fully built.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:482
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_n_o_t_b_u_i_l_t
│ │ │ │ │ -@ notbuilt
│ │ │ │ │ -Matrix is not built at all, no memory has been allocated, build mode and size
│ │ │ │ │ -can still be set.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:471
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_n_o_t_A_l_l_o_c_a_t_e_d
│ │ │ │ │ -@ notAllocated
│ │ │ │ │ -Matrix is not built at all, no memory has been allocated, build mode and size
│ │ │ │ │ -can still be set.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:473
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_u_i_l_d_i_n_g
│ │ │ │ │ -@ building
│ │ │ │ │ -Matrix is currently being built, some memory has been allocated, build mode and
│ │ │ │ │ -size are fixed.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:475
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_u_i_l_d_M_o_d_e
│ │ │ │ │ -BuildMode buildMode() const
│ │ │ │ │ -The currently selected build mode of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2028
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_m_m_v
│ │ │ │ │ -void mmv(const X &x, Y &y) const
│ │ │ │ │ -y -= A x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1690
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_i_n_f_i_n_i_t_y___n_o_r_m
│ │ │ │ │ -FieldTraits< ft >::real_type infinity_norm() const
│ │ │ │ │ -infinity norm (row sum norm, how to generalize for blocks?)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1914
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_m_v
│ │ │ │ │ -void mv(const X &x, Y &y) const
│ │ │ │ │ -y = A x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1641
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ -B block_type
│ │ │ │ │ -export the type representing the components
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:491
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_m_m_t_v
│ │ │ │ │ -void mmtv(const X &x, Y &y) const
│ │ │ │ │ -y -= A^T x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1774
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_v_g
│ │ │ │ │ -size_type avg
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2075
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_u_m_v
│ │ │ │ │ -void umv(const X &x, Y &y) const
│ │ │ │ │ -y += A x
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1667
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_i_m_p_l_i_c_i_t___a_l_l_o_c_a_t_e
│ │ │ │ │ -void implicit_allocate(size_type _n, size_type _m)
│ │ │ │ │ -organizes allocation implicit mode calculates correct array size to be
│ │ │ │ │ -allocated and sets the the win...
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2295
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_I_m_p_l_i_c_i_t_B_u_i_l_d_M_o_d_e_P_a_r_a_m_e_t_e_r_s
│ │ │ │ │ -void setImplicitBuildModeParameters(size_type _avg, double
│ │ │ │ │ -compressionBufferSize)
│ │ │ │ │ -Set parameters needed for creation in implicit build mode.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:886
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ -BCRSMatrix(size_type _n, size_type _m, BuildMode bm)
│ │ │ │ │ -matrix with unknown number of nonzeroes
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:761
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_d_i_n_d_i_c_e_s
│ │ │ │ │ -void endindices()
│ │ │ │ │ -indicate that all indices are defined, check consistency
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1269
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_c_o_m_p_r_e_s_s
│ │ │ │ │ -CompressionStatistics compress()
│ │ │ │ │ -Finishes the buildstage in implicit mode.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1381
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_D_a_t_a_P_o_i_n_t_e_r_s
│ │ │ │ │ -void setDataPointers()
│ │ │ │ │ -Set data pointers for all rows.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2132
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_o_r__
│ │ │ │ │ -std::allocator_traits< A >::template rebind_alloc< B > allocator_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2052
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_N
│ │ │ │ │ -size_type N() const
│ │ │ │ │ -number of rows (counted in blocks)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2001
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_B_u_i_l_d_M_o_d_e
│ │ │ │ │ -void setBuildMode(BuildMode bm)
│ │ │ │ │ -Sets the build mode of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:830
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_S_i_z_e
│ │ │ │ │ -void setSize(size_type rows, size_type columns, size_type nnz=0)
│ │ │ │ │ -Set the size of the matrix.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:858
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_j__
│ │ │ │ │ -std::shared_ptr< size_type > j_
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2072
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_W_i_n_d_o_w_P_o_i_n_t_e_r_s
│ │ │ │ │ -void setWindowPointers(ConstRowIterator row)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2081
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ -BCRSMatrix & operator=(const BCRSMatrix &Mat)
│ │ │ │ │ -assignment
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:908
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_e_t_C_o_l_u_m_n_P_o_i_n_t_e_r_s
│ │ │ │ │ -void setColumnPointers(ConstRowIterator row)
│ │ │ │ │ -Copy row sizes from iterator range starting at row and set column index
│ │ │ │ │ -pointers for all rows.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2106
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_e_n_d
│ │ │ │ │ -ConstIterator end() const
│ │ │ │ │ -Get const iterator to one beyond last row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:714
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_e_g_i_n
│ │ │ │ │ -ConstIterator begin() const
│ │ │ │ │ -Get const iterator to first row.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:708
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e
│ │ │ │ │ -A allocator_type
│ │ │ │ │ -export the allocator type
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:494
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_b_e_f_o_r_e_E_n_d
│ │ │ │ │ -ConstIterator beforeEnd() const
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:721
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator access to matrix rows
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:575
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator()
│ │ │ │ │ -empty constructor, use with care!
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:592
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_e_q_u_a_l_s
│ │ │ │ │ -bool equals(const RealRowIterator< ValueType > &other) const
│ │ │ │ │ -equality
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:620
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_V_a_l_u_e_T_y_p_e
│ │ │ │ │ -std::remove_const< T >::type ValueType
│ │ │ │ │ -The unqualified value type.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:579
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator(const RealRowIterator< ValueType > &it)
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:596
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_e_q_u_a_l_s
│ │ │ │ │ -bool equals(const RealRowIterator< const ValueType > &other) const
│ │ │ │ │ -equality
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:627
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r
│ │ │ │ │ -RealRowIterator(row_type *_p, size_type _i)
│ │ │ │ │ -constructor
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:587
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_d_i_s_t_a_n_c_e_T_o
│ │ │ │ │ -std::ptrdiff_t distanceTo(const RealRowIterator< const ValueType > &other)
│ │ │ │ │ -const
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:613
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_i_n_d_e_x
│ │ │ │ │ -size_type index() const
│ │ │ │ │ -return index
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:602
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_R_e_a_l_R_o_w_I_t_e_r_a_t_o_r_:_:_d_i_s_t_a_n_c_e_T_o
│ │ │ │ │ -std::ptrdiff_t distanceTo(const RealRowIterator< ValueType > &other) const
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:607
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ -Iterator class for sequential creation of blocks
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:954
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_=_=
│ │ │ │ │ -bool operator==(const CreateIterator &it) const
│ │ │ │ │ -equality
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1049
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_+_+
│ │ │ │ │ -CreateIterator & operator++()
│ │ │ │ │ -prefix increment
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:974
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_i_n_d_e_x
│ │ │ │ │ -size_type index() const
│ │ │ │ │ -The number of the row that the iterator currently points to.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1055
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_o_p_e_r_a_t_o_r_!_=
│ │ │ │ │ -bool operator!=(const CreateIterator &it) const
│ │ │ │ │ -inequality
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1043
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r
│ │ │ │ │ -CreateIterator(BCRSMatrix &_Mat, size_type _i)
│ │ │ │ │ -constructor
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:957
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_i_n_s_e_r_t
│ │ │ │ │ -void insert(size_type j)
│ │ │ │ │ -put column index in row
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1061
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_c_o_n_t_a_i_n_s
│ │ │ │ │ -bool contains(size_type j)
│ │ │ │ │ -return true if column index is in row
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1067
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_C_r_e_a_t_e_I_t_e_r_a_t_o_r_:_:_s_i_z_e
│ │ │ │ │ -size_type size() const
│ │ │ │ │ -Get the current row size.
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:1076
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ -typename BCRSMatrix< B, A >::field_type field_type
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2329
│ │ │ │ │ -_D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_r_e_a_l___t_y_p_e
│ │ │ │ │ -typename FieldTraits< field_type >::real_type real_type
│ │ │ │ │ -DDeeffiinniittiioonn bcrsmatrix.hh:2330
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_E_r_r_o_r
│ │ │ │ │ -Error specific to BCRSMatrix.
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:24
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_o_d_e_C_o_m_p_r_e_s_s_i_o_n_B_u_f_f_e_r_E_x_h_a_u_s_t_e_d
│ │ │ │ │ -Thrown when the compression buffer used by the implicit BCRSMatrix construction
│ │ │ │ │ -is exhausted.
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:37
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x
│ │ │ │ │ -A generic dynamic dense matrix.
│ │ │ │ │ -DDeeffiinniittiioonn matrix.hh:561
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ -A::size_type size_type
│ │ │ │ │ -Type for indices and sizes.
│ │ │ │ │ -DDeeffiinniittiioonn matrix.hh:577
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e
│ │ │ │ │ -T block_type
│ │ │ │ │ -Export the type representing the components.
│ │ │ │ │ -DDeeffiinniittiioonn matrix.hh:568
│ │ │ │ │ -_D_u_n_e_:_:_P_o_i_n_t_e_r_C_o_m_p_a_r_e
│ │ │ │ │ -DDeeffiinniittiioonn matrixutils.hh:538
│ │ │ │ │ +_D_u_n_e_:_:_A_s_s_e_m_b_l_e_d_L_i_n_e_a_r_O_p_e_r_a_t_o_r
│ │ │ │ │ +A linear operator exporting itself in matrix form.
│ │ │ │ │ +DDeeffiinniittiioonn operators.hh:111
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r
│ │ │ │ │ +An overlapping Schwarz operator.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:75
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_g_e_t_C_o_m_m_u_n_i_c_a_t_i_o_n
│ │ │ │ │ +const communication_type & getCommunication() const
│ │ │ │ │ +Get the object responsible for communication.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:146
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_g_e_t_m_a_t
│ │ │ │ │ +virtual const matrix_type & getmat() const
│ │ │ │ │ +get the sequential assembled linear operator.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:133
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_a_p_p_l_y_s_c_a_l_e_a_d_d
│ │ │ │ │ +virtual void applyscaleadd(field_type alpha, const X &x, Y &y) const
│ │ │ │ │ +apply operator to x, scale and add:
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:125
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(const X &x, Y &y) const
│ │ │ │ │ +apply operator to x:
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:116
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e
│ │ │ │ │ +C communication_type
│ │ │ │ │ +The type of the communication object.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:98
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The type of the domain.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:86
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The type of the matrix we operate on.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:81
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The type of the range.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:91
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the range.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:93
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r
│ │ │ │ │ +OverlappingSchwarzOperator(const matrix_type &A, const communication_type &com)
│ │ │ │ │ +constructor: just store a reference to a matrix.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:107
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r
│ │ │ │ │ +OverlappingSchwarzOperator(const std::shared_ptr< matrix_type > A, const
│ │ │ │ │ +communication_type &com)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:111
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_O_p_e_r_a_t_o_r_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the linear operator (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:139
│ │ │ │ │ +_D_u_n_e_:_:_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +Base class for matrix free definition of preconditioners.
│ │ │ │ │ +DDeeffiinniittiioonn preconditioner.hh:33
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R
│ │ │ │ │ +A parallel SSOR preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:175
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:184
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e
│ │ │ │ │ +C communication_type
│ │ │ │ │ +The type of the communication object.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:186
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:233
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_P_a_r_S_S_O_R
│ │ │ │ │ +ParSSOR(const matrix_type &A, int n, field_type w, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:197
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:230
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:180
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:182
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +M matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:178
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:216
│ │ │ │ │ +_D_u_n_e_:_:_P_a_r_S_S_O_R_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:206
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +Block parallel preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:278
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_p_r_e
│ │ │ │ │ +virtual void pre(X &x, Y &b)
│ │ │ │ │ +Prepare the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:326
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_d_o_m_a_i_n___t_y_p_e
│ │ │ │ │ +X domain_type
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:285
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +BlockPreconditioner(const std::shared_ptr< P > &p, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:317
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:337
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +BlockPreconditioner(P &p, const communication_type &c)
│ │ │ │ │ +Constructor.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:306
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +void apply(X &v, const Y &d)
│ │ │ │ │ +Apply one step of the preconditioner to the system A(v)=d.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:344
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_c_o_m_m_u_n_i_c_a_t_i_o_n___t_y_p_e
│ │ │ │ │ +C communication_type
│ │ │ │ │ +The type of the communication object..
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:297
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_f_i_e_l_d___t_y_p_e
│ │ │ │ │ +X::field_type field_type
│ │ │ │ │ +The field type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:292
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_p_o_s_t
│ │ │ │ │ +virtual void post(X &x)
│ │ │ │ │ +Clean up.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:355
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_r_a_n_g_e___t_y_p_e
│ │ │ │ │ +Y range_type
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:290
│ │ │ │ │ +_D_u_n_e_:_:_B_l_o_c_k_P_r_e_c_o_n_d_i_t_i_o_n_e_r_:_:_c_a_t_e_g_o_r_y
│ │ │ │ │ +virtual SolverCategory::Category category() const
│ │ │ │ │ +Category of the preconditioner (see SolverCategory::Category)
│ │ │ │ │ +DDeeffiinniittiioonn schwarz.hh:361
│ │ │ │ │ +_D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_C_a_t_e_g_o_r_y
│ │ │ │ │ +Category
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:23
│ │ │ │ │ +_D_u_n_e_:_:_S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_o_v_e_r_l_a_p_p_i_n_g
│ │ │ │ │ +@ overlapping
│ │ │ │ │ +Category for overlapping solvers.
│ │ │ │ │ +DDeeffiinniittiioonn solvercategory.hh:29
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00014.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: istlexception.hh File Reference
│ │ │ │ +dune-istl: supermatrix.hh File Reference
│ │ │ │ dune istl
│ │ │ │ -
#include <dune/common/exceptions.hh>
│ │ │ │ +
#include "bcrsmatrix.hh "
│ │ │ │ +
#include "bvector.hh "
│ │ │ │
#include <dune/common/fmatrix.hh>
│ │ │ │ +
#include <dune/common/fvector.hh>
│ │ │ │ +
#include <dune/common/typetraits.hh>
│ │ │ │ +
#include <limits>
│ │ │ │ +
#include <dune/istl/bccsmatrixinitializer.hh >
│ │ │ │ +
#include "superlufunctions.hh "
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ namespace Dune
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,33 +1,50 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ _C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ -istlexception.hh File Reference
│ │ │ │ │ -#include
│ │ │ │ │ +supermatrix.hh File Reference
│ │ │ │ │ +#include "_b_c_r_s_m_a_t_r_i_x_._h_h"
│ │ │ │ │ +#include "_b_v_e_c_t_o_r_._h_h"
│ │ │ │ │ #include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_b_c_c_s_m_a_t_r_i_x_i_n_i_t_i_a_l_i_z_e_r_._h_h>
│ │ │ │ │ +#include "_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h"
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ CCllaasssseess
│ │ │ │ │ -class _D_u_n_e_:_:_I_S_T_L_E_r_r_o_r
│ │ │ │ │ - derive error class from the base class in common _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r_<_ _T_ _>
│ │ │ │ │
│ │ │ │ │ -class _D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_E_r_r_o_r
│ │ │ │ │ - Error specific to _B_C_R_S_M_a_t_r_i_x. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_P_r_i_n_t_e_r_<_ _T_ _>
│ │ │ │ │
│ │ │ │ │ -class _D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_o_d_e_C_o_m_p_r_e_s_s_i_o_n_B_u_f_f_e_r_E_x_h_a_u_s_t_e_d
│ │ │ │ │ - Thrown when the compression buffer used by the implicit _B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ - construction is exhausted. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _T_ _>
│ │ │ │ │
│ │ │ │ │ -class _D_u_n_e_:_:_S_o_l_v_e_r_A_b_o_r_t
│ │ │ │ │ - Thrown when a solver aborts due to some problem. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _T_ _>
│ │ │ │ │
│ │ │ │ │ -class _D_u_n_e_:_:_M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r
│ │ │ │ │ - Error when performing an operation on a matrix block. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _d_o_u_b_l_e_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _f_l_o_a_t_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _d_o_u_b_l_e_ _>_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _f_l_o_a_t_ _>_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _M_ _>
│ │ │ │ │ + Utility class for converting an _I_S_T_L _M_a_t_r_i_x into a _S_u_p_e_r_L_U _M_a_t_r_i_x.
│ │ │ │ │ + _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _M_ _>
│ │ │ │ │ +
│ │ │ │ │ + class _D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>
│ │ │ │ │ + Converter for _B_C_R_S_M_a_t_r_i_x to _S_u_p_e_r_L_U _M_a_t_r_i_x. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ + class _D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00014_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: istlexception.hh Source File
│ │ │ │ +dune-istl: supermatrix.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_ISTL_ISTLEXCEPTION_HH
│ │ │ │ -
6 #define DUNE_ISTL_ISTLEXCEPTION_HH
│ │ │ │ +
5 #ifndef DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ +
6 #define DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │
│ │ │ │ -
8 #include <dune/common/exceptions.hh>
│ │ │ │ -
9 #include <dune/common/fmatrix.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
12 #include <dune/common/fmatrix.hh>
│ │ │ │ +
13 #include <dune/common/fvector.hh>
│ │ │ │ +
14 #include <dune/common/typetraits.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
32 #if __has_include("slu_sdefs.h")
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
36 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ +
37 float *values,
int *rowindex,
int * colindex,
│ │ │ │ +
38 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ +
│ │ │ │ +
40 sCreate_CompCol_Matrix(
mat , n, m, offset, values, rowindex, colindex,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
46 struct SuperMatrixPrinter<float>
│ │ │ │ +
│ │ │ │ +
48 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ +
│ │ │ │ +
50 sPrint_CompCol_Matrix(name,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
55 #if __has_include("slu_ddefs.h")
│ │ │ │ +
│ │ │ │ +
57 struct SuperMatrixCreateSparseChooser<double>
│ │ │ │ +
│ │ │ │ +
59 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ +
60 double *values,
int *rowindex,
int * colindex,
│ │ │ │ +
61 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ +
│ │ │ │ +
63 dCreate_CompCol_Matrix(
mat , n, m, offset, values, rowindex, colindex,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
69 struct SuperMatrixPrinter<double>
│ │ │ │ +
│ │ │ │ +
71 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ +
│ │ │ │ +
73 dPrint_CompCol_Matrix(name,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
78 #if __has_include("slu_cdefs.h")
│ │ │ │ +
│ │ │ │ +
80 struct SuperMatrixCreateSparseChooser<
std ::complex<float> >
│ │ │ │ +
│ │ │ │ +
82 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ +
83 std::complex<float> *values,
int *rowindex,
int * colindex,
│ │ │ │ +
84 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ +
│ │ │ │ +
86 cCreate_CompCol_Matrix(
mat , n, m, offset,
reinterpret_cast< ::complex*
> (values),
│ │ │ │ +
87 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
92 struct SuperMatrixPrinter<
std ::complex<float> >
│ │ │ │ +
│ │ │ │ +
94 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ +
│ │ │ │ +
96 cPrint_CompCol_Matrix(name,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
101 #if __has_include("slu_zdefs.h")
│ │ │ │ +
│ │ │ │ +
103 struct SuperMatrixCreateSparseChooser<
std ::complex<double> >
│ │ │ │ +
│ │ │ │ +
105 static void create(SuperMatrix *
mat ,
int n,
int m,
int offset,
│ │ │ │ +
106 std::complex<double> *values,
int *rowindex,
int * colindex,
│ │ │ │ +
107 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ +
│ │ │ │ +
109 zCreate_CompCol_Matrix(
mat , n, m, offset,
reinterpret_cast< doublecomplex*
> (values),
│ │ │ │ +
110 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
115 struct SuperMatrixPrinter<
std ::complex<double> >
│ │ │ │ +
│ │ │ │ +
117 static void print(
char * name, SuperMatrix*
mat )
│ │ │ │ +
│ │ │ │ +
119 zPrint_CompCol_Matrix(name,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
136 std::is_same<T,float>::value ? SLU_S :
│ │ │ │ +
137 ( std::is_same<T,std::complex<double> >::value ? SLU_Z :
│ │ │ │ +
138 ( std::is_same<T,std::complex<float> >::value ? SLU_C : SLU_D ));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
184 template <
class M,
class X,
class TM,
class TD,
class T1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
187 template <
class T,
bool flag>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
193 template <
class B,
class TA>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
195 :
public ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type, int>
│ │ │ │ +
│ │ │ │ +
197 template <
class M,
class X,
class TM,
class TD,
class T1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
221 if (this->N_+this->M_*this->Nnz_ != 0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
226 operator SuperMatrix&()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
232 operator const SuperMatrix&()
const
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
239 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
245 ISTL::Impl::BCCSMatrixInitializer<Matrix, int> initializer(*
this );
│ │ │ │ +
│ │ │ │ +
247 copyToBCCSMatrix(initializer,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
250 ::create (&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ +
251 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
258 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
264 ISTL::Impl::BCCSMatrixInitializer<Matrix, int> initializer(*
this );
│ │ │ │ +
│ │ │ │ +
266 copyToBCCSMatrix(initializer,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
269 ::create (&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ +
270 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
283 if (this->N_+this->M_+this->Nnz_!=0)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
289 copyToBCCSMatrix(initializer, ISTL::Impl::MatrixRowSubset<
Matrix ,std::set<std::size_t> >(
mat ,mrs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
299 copyToBCCSMatrix(initializer,
mat );
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
305 ISTL::Impl::BCCSMatrix<typename BCRSMatrix<B,TA>::field_type,
int >::free();
│ │ │ │ +
306 SUPERLU_FREE(A.Store);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
312 template <
class B,
class A>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
314 :
public ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>, int>
│ │ │ │ +
│ │ │ │ +
316 template <
class I,
class S,
class D>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
331 ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<B,A>,
int >::createMatrix();
│ │ │ │ +
│ │ │ │ +
333 ::create (&slumat->A, slumat->N_, slumat->M_, slumat->colstart[this->cols],
│ │ │ │ +
334 slumat->values,slumat->rowindex, slumat->colstart, SLU_NC,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Implementation of the BCRSMatrix class.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
This file implements a vector space as a tensor product of a given vector space. The number of compon...
│ │ │ │ +
Matrix & mat
Definition matrixmatrix.hh:347
│ │ │ │ +
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ -
Error specific to BCRSMatrix.
Definition istlexception.hh:24
│ │ │ │ -
Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted.
Definition istlexception.hh:37
│ │ │ │ -
Thrown when a solver aborts due to some problem.
Definition istlexception.hh:46
│ │ │ │ -
Error when performing an operation on a matrix block.
Definition istlexception.hh:52
│ │ │ │ -
int c
Definition istlexception.hh:54
│ │ │ │ -
int r
Definition istlexception.hh:54
│ │ │ │ +
Initializer for SuperLU Matrices representing the subdomains.
Definition overlappingschwarz.hh:47
│ │ │ │ +
static auto coldim(const M &A)
Definition matrixutils.hh:219
│ │ │ │ +
static auto rowdim(const M &A)
Definition matrixutils.hh:214
│ │ │ │ +
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ +
A::size_type size_type
The type for the index access and the size.
Definition bcrsmatrix.hh:497
│ │ │ │ +
Sequential overlapping Schwarz preconditioner.
Definition overlappingschwarz.hh:755
│ │ │ │ +
Definition overlappingschwarz.hh:694
│ │ │ │ +
SuperLu Solver.
Definition superlu.hh:271
│ │ │ │ +
Definition supermatrix.hh:26
│ │ │ │ +
Definition supermatrix.hh:30
│ │ │ │ +
Definition supermatrix.hh:126
│ │ │ │ +
static const Dtype_t type
Definition supermatrix.hh:127
│ │ │ │ +
Definition supermatrix.hh:132
│ │ │ │ +
double float_type
Definition supermatrix.hh:144
│ │ │ │ +
float float_type
Definition supermatrix.hh:151
│ │ │ │ +
double float_type
Definition supermatrix.hh:158
│ │ │ │ +
float float_type
Definition supermatrix.hh:165
│ │ │ │ +
Utility class for converting an ISTL Matrix into a SuperLU Matrix.
Definition supermatrix.hh:175
│ │ │ │ +
Definition supermatrix.hh:179
│ │ │ │ +
virtual void free()
free allocated space.
Definition supermatrix.hh:303
│ │ │ │ +
SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const SuperLUMatrix< BCRSMatrix< B, TA > > &mat)
Definition supermatrix.hh:256
│ │ │ │ +
SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const BCRSMatrix< B, TA > &mat)
Definition supermatrix.hh:237
│ │ │ │ +
SuperLUMatrix(const Matrix &mat)
Constructor that initializes the data.
Definition supermatrix.hh:212
│ │ │ │ +
virtual void setMatrix(const Matrix &mat)
Initialize data from given matrix.
Definition supermatrix.hh:293
│ │ │ │ +
SuperLUMatrix()
Definition supermatrix.hh:215
│ │ │ │ +
Matrix::size_type size_type
Definition supermatrix.hh:206
│ │ │ │ +
BCRSMatrix< B, TA > Matrix
The type of the matrix to convert.
Definition supermatrix.hh:202
│ │ │ │ +
virtual void setMatrix(const Matrix &mat, const std::set< std::size_t > &mrs)
Initialize data from a given set of matrix rows and columns.
Definition supermatrix.hh:281
│ │ │ │ +
virtual ~SuperLUMatrix()
Destructor.
Definition supermatrix.hh:219
│ │ │ │ +
Dune::SuperLUMatrix< Matrix > SuperLUMatrix
Definition supermatrix.hh:320
│ │ │ │ +
BCRSMatrix< B, A > Matrix
Definition supermatrix.hh:319
│ │ │ │ +
SuperMatrixInitializer()
Definition supermatrix.hh:326
│ │ │ │ +
virtual void createMatrix() const
Definition supermatrix.hh:329
│ │ │ │ +
SuperMatrixInitializer(SuperLUMatrix &lum)
Definition supermatrix.hh:322
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,69 +1,461 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -istlexception.hh
│ │ │ │ │ +supermatrix.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ 3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 4// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ -5#ifndef DUNE_ISTL_ISTLEXCEPTION_HH
│ │ │ │ │ -6#define DUNE_ISTL_ISTLEXCEPTION_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ │ +6#define DUNE_ISTL_SUPERMATRIX_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#include
│ │ │ │ │ -9#include
│ │ │ │ │ -10
│ │ │ │ │ -11namespace _D_u_n_e {
│ │ │ │ │ -12
│ │ │ │ │ -_1_9 class _I_S_T_L_E_r_r_o_r : public Dune::MathError {};
│ │ │ │ │ +8#if HAVE_SUPERLU
│ │ │ │ │ +9
│ │ │ │ │ +10#include "_b_c_r_s_m_a_t_r_i_x_._h_h"
│ │ │ │ │ +11#include "_b_v_e_c_t_o_r_._h_h"
│ │ │ │ │ +12#include
│ │ │ │ │ +13#include
│ │ │ │ │ +14#include
│ │ │ │ │ +15#include
│ │ │ │ │ +16
│ │ │ │ │ +17#include <_d_u_n_e_/_i_s_t_l_/_b_c_c_s_m_a_t_r_i_x_i_n_i_t_i_a_l_i_z_e_r_._h_h>
│ │ │ │ │ +18
│ │ │ │ │ +19#include "_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h"
│ │ │ │ │ 20
│ │ │ │ │ -_2_2 class _B_C_R_S_M_a_t_r_i_x_E_r_r_o_r
│ │ │ │ │ -23 : public _I_S_T_L_E_r_r_o_r
│ │ │ │ │ -24 {};
│ │ │ │ │ -25
│ │ │ │ │ -_3_5 class _I_m_p_l_i_c_i_t_M_o_d_e_C_o_m_p_r_e_s_s_i_o_n_B_u_f_f_e_r_E_x_h_a_u_s_t_e_d
│ │ │ │ │ -36 : public _B_C_R_S_M_a_t_r_i_x_E_r_r_o_r
│ │ │ │ │ -37 {};
│ │ │ │ │ -38
│ │ │ │ │ -40
│ │ │ │ │ -_4_6 class _S_o_l_v_e_r_A_b_o_r_t : public _I_S_T_L_E_r_r_o_r {};
│ │ │ │ │ -47
│ │ │ │ │ -49
│ │ │ │ │ -_5_2 class _M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r : public virtual Dune::FMatrixError {
│ │ │ │ │ -53 public:
│ │ │ │ │ -_5_4 int _r, _c; // row and column index of the entry from which the error resulted
│ │ │ │ │ -55 };
│ │ │ │ │ -56
│ │ │ │ │ -59} // end namespace
│ │ │ │ │ -60
│ │ │ │ │ -61#endif
│ │ │ │ │ +21namespace _D_u_n_e
│ │ │ │ │ +22{
│ │ │ │ │ +23
│ │ │ │ │ +24 template
│ │ │ │ │ +_2_5 struct _S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r
│ │ │ │ │ +26 {};
│ │ │ │ │ +27
│ │ │ │ │ +28 template
│ │ │ │ │ +_2_9 struct _S_u_p_e_r_M_a_t_r_i_x_P_r_i_n_t_e_r
│ │ │ │ │ +30 {};
│ │ │ │ │ +31
│ │ │ │ │ +32#if __has_include("slu_sdefs.h")
│ │ │ │ │ +33 template<>
│ │ │ │ │ +34 struct _S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r
│ │ │ │ │ +35 {
│ │ │ │ │ +36 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ +37 float *values, int *rowindex, int* colindex,
│ │ │ │ │ +38 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ +39 {
│ │ │ │ │ +40 sCreate_CompCol_Matrix(_m_a_t, n, m, offset, values, rowindex, colindex,
│ │ │ │ │ +41 stype, dtype, mtype);
│ │ │ │ │ +42 }
│ │ │ │ │ +43 };
│ │ │ │ │ +44
│ │ │ │ │ +45 template<>
│ │ │ │ │ +46 struct SuperMatrixPrinter
│ │ │ │ │ +47 {
│ │ │ │ │ +48 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ +49 {
│ │ │ │ │ +50 sPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ +51 }
│ │ │ │ │ +52 };
│ │ │ │ │ +53#endif
│ │ │ │ │ +54
│ │ │ │ │ +55#if __has_include("slu_ddefs.h")
│ │ │ │ │ +56 template<>
│ │ │ │ │ +57 struct SuperMatrixCreateSparseChooser
│ │ │ │ │ +58 {
│ │ │ │ │ +59 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ +60 double *values, int *rowindex, int* colindex,
│ │ │ │ │ +61 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ +62 {
│ │ │ │ │ +63 dCreate_CompCol_Matrix(_m_a_t, n, m, offset, values, rowindex, colindex,
│ │ │ │ │ +64 stype, dtype, mtype);
│ │ │ │ │ +65 }
│ │ │ │ │ +66 };
│ │ │ │ │ +67
│ │ │ │ │ +68 template<>
│ │ │ │ │ +69 struct SuperMatrixPrinter
│ │ │ │ │ +70 {
│ │ │ │ │ +71 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ +72 {
│ │ │ │ │ +73 dPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ +74 }
│ │ │ │ │ +75 };
│ │ │ │ │ +76#endif
│ │ │ │ │ +77
│ │ │ │ │ +78#if __has_include("slu_cdefs.h")
│ │ │ │ │ +79 template<>
│ │ │ │ │ +80 struct SuperMatrixCreateSparseChooser<_s_t_d::complex >
│ │ │ │ │ +81 {
│ │ │ │ │ +82 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ +83 std::complex *values, int *rowindex, int* colindex,
│ │ │ │ │ +84 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ +85 {
│ │ │ │ │ +86 cCreate_CompCol_Matrix(_m_a_t, n, m, offset, reinterpret_cast< ::complex*>
│ │ │ │ │ +(values),
│ │ │ │ │ +87 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ │ +88 }
│ │ │ │ │ +89 };
│ │ │ │ │ +90
│ │ │ │ │ +91 template<>
│ │ │ │ │ +92 struct SuperMatrixPrinter<_s_t_d::complex >
│ │ │ │ │ +93 {
│ │ │ │ │ +94 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ +95 {
│ │ │ │ │ +96 cPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ +97 }
│ │ │ │ │ +98 };
│ │ │ │ │ +99#endif
│ │ │ │ │ +100
│ │ │ │ │ +101#if __has_include("slu_zdefs.h")
│ │ │ │ │ +102 template<>
│ │ │ │ │ +103 struct SuperMatrixCreateSparseChooser<_s_t_d::complex >
│ │ │ │ │ +104 {
│ │ │ │ │ +105 static void create(SuperMatrix *_m_a_t, int n, int m, int offset,
│ │ │ │ │ +106 std::complex *values, int *rowindex, int* colindex,
│ │ │ │ │ +107 Stype_t stype, Dtype_t dtype, Mtype_t mtype)
│ │ │ │ │ +108 {
│ │ │ │ │ +109 zCreate_CompCol_Matrix(_m_a_t, n, m, offset, reinterpret_cast
│ │ │ │ │ +(values),
│ │ │ │ │ +110 rowindex, colindex, stype, dtype, mtype);
│ │ │ │ │ +111 }
│ │ │ │ │ +112 };
│ │ │ │ │ +113
│ │ │ │ │ +114 template<>
│ │ │ │ │ +115 struct SuperMatrixPrinter<_s_t_d::complex >
│ │ │ │ │ +116 {
│ │ │ │ │ +117 static void print(char* name, SuperMatrix* _m_a_t)
│ │ │ │ │ +118 {
│ │ │ │ │ +119 zPrint_CompCol_Matrix(name, _m_a_t);
│ │ │ │ │ +120 }
│ │ │ │ │ +121 };
│ │ │ │ │ +122#endif
│ │ │ │ │ +123
│ │ │ │ │ +124 template
│ │ │ │ │ +_1_2_5 struct _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +126 {
│ │ │ │ │ +_1_2_7 static const Dtype_t _t_y_p_e;
│ │ │ │ │ +128 };
│ │ │ │ │ +129
│ │ │ │ │ +130 template
│ │ │ │ │ +_1_3_1 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +132 {};
│ │ │ │ │ +133
│ │ │ │ │ +134 template
│ │ │ │ │ +135 const Dtype_t _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_T_>_:_:_t_y_p_e =
│ │ │ │ │ +136 std::is_same::value ? SLU_S :
│ │ │ │ │ +137 ( std::is_same >::value ? SLU_Z :
│ │ │ │ │ +138 ( std::is_same >::value ? SLU_C : SLU_D ));
│ │ │ │ │ +139
│ │ │ │ │ +140 template<>
│ │ │ │ │ +_1_4_1 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +142 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +143 {
│ │ │ │ │ +_1_4_4 typedef double _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ +145 };
│ │ │ │ │ +146
│ │ │ │ │ +147 template<>
│ │ │ │ │ +_1_4_8 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +149 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +150 {
│ │ │ │ │ +_1_5_1 typedef float _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ +152 };
│ │ │ │ │ +153
│ │ │ │ │ +154 template<>
│ │ │ │ │ +_1_5_5 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e<_s_t_d::complex >
│ │ │ │ │ +156 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e >
│ │ │ │ │ +157 {
│ │ │ │ │ +_1_5_8 typedef double _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ +159 };
│ │ │ │ │ +160
│ │ │ │ │ +161 template<>
│ │ │ │ │ +_1_6_2 struct _G_e_t_S_u_p_e_r_L_U_T_y_p_e<_s_t_d::complex >
│ │ │ │ │ +163 : public _B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e >
│ │ │ │ │ +164 {
│ │ │ │ │ +_1_6_5 typedef float _f_l_o_a_t___t_y_p_e;
│ │ │ │ │ +166
│ │ │ │ │ +167 };
│ │ │ │ │ +168
│ │ │ │ │ +173 template
│ │ │ │ │ +_1_7_4 struct _S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +175 {};
│ │ │ │ │ +176
│ │ │ │ │ +177 template
│ │ │ │ │ +_1_7_8 struct _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ +179 {};
│ │ │ │ │ +180
│ │ │ │ │ +181 template
│ │ │ │ │ +182 class _S_u_p_e_r_L_U;
│ │ │ │ │ +183
│ │ │ │ │ +184 template
│ │ │ │ │ +185 class _S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z;
│ │ │ │ │ +186
│ │ │ │ │ +187 template
│ │ │ │ │ +188 struct _S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_A_s_s_e_m_b_l_e_r_H_e_l_p_e_r;
│ │ │ │ │ +189
│ │ │ │ │ +193 template
│ │ │ │ │ +_1_9_4 class _S_u_p_e_r_L_U_M_a_t_r_i_x<_B_C_R_S_M_a_t_r_i_x >
│ │ │ │ │ +195 : public ISTL::Impl::BCCSMatrix::field_type, int>
│ │ │ │ │ +196 {
│ │ │ │ │ +197 template
│ │ │ │ │ +_1_9_8 friend class _S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z;
│ │ │ │ │ +199 friend struct _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r<_B_C_R_S_M_a_t_r_i_x >;
│ │ │ │ │ +200 public:
│ │ │ │ │ +_2_0_2 typedef _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_> _M_a_t_r_i_x;
│ │ │ │ │ +203
│ │ │ │ │ +204 friend struct _S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_A_s_s_e_m_b_l_e_r_H_e_l_p_e_r<_S_u_p_e_r_L_U<_M_a_t_r_i_x>, true>;
│ │ │ │ │ +205
│ │ │ │ │ +_2_0_6 typedef typename _M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e _s_i_z_e___t_y_p_e;
│ │ │ │ │ +207
│ │ │ │ │ +_2_1_2 explicit _S_u_p_e_r_L_U_M_a_t_r_i_x(const _M_a_t_r_i_x& _m_a_t) : ISTL::Impl::
│ │ │ │ │ +BCCSMatrix<_B_C_R_S_M_a_t_r_i_x, int>(_m_a_t)
│ │ │ │ │ +213 {}
│ │ │ │ │ +214
│ │ │ │ │ +_2_1_5 _S_u_p_e_r_L_U_M_a_t_r_i_x() : ISTL::Impl::BCCSMatrix::
│ │ │ │ │ +field_type, int>()
│ │ │ │ │ +216 {}
│ │ │ │ │ +217
│ │ │ │ │ +_2_1_9 virtual _~_S_u_p_e_r_L_U_M_a_t_r_i_x()
│ │ │ │ │ +220 {
│ │ │ │ │ +221 if (this->N_+this->M_*this->Nnz_ != 0)
│ │ │ │ │ +222 free();
│ │ │ │ │ +223 }
│ │ │ │ │ +224
│ │ │ │ │ +_2_2_6 operator SuperMatrix&()
│ │ │ │ │ +227 {
│ │ │ │ │ +228 return A;
│ │ │ │ │ +229 }
│ │ │ │ │ +230
│ │ │ │ │ +_2_3_2 operator const SuperMatrix&() const
│ │ │ │ │ +233 {
│ │ │ │ │ +234 return A;
│ │ │ │ │ +235 }
│ │ │ │ │ +236
│ │ │ │ │ +_2_3_7 _S_u_p_e_r_L_U_M_a_t_r_i_x_<_B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_> >& _o_p_e_r_a_t_o_r_=(const _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_>& _m_a_t)
│ │ │ │ │ +238 {
│ │ │ │ │ +239 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ │ +240 free();
│ │ │ │ │ +241
│ │ │ │ │ +242 using _M_a_t_r_i_x = _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_>;
│ │ │ │ │ +243 this->N_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_r_o_w_d_i_m(_m_a_t);
│ │ │ │ │ +244 this->M_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_c_o_l_d_i_m(_m_a_t);
│ │ │ │ │ +245 ISTL::Impl::BCCSMatrixInitializer initializer(*this);
│ │ │ │ │ +246
│ │ │ │ │ +247 copyToBCCSMatrix(initializer, _m_a_t);
│ │ │ │ │ +248
│ │ │ │ │ +249 _S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>
│ │ │ │ │ +250_ _:_:_c_r_e_a_t_e(&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ │ +251 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ │ +252 static_cast(_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>_:_:_t_y_p_e),
│ │ │ │ │ +SLU_GE);
│ │ │ │ │ +253 return *this;
│ │ │ │ │ +254 }
│ │ │ │ │ +255
│ │ │ │ │ +_2_5_6 _S_u_p_e_r_L_U_M_a_t_r_i_x_<_B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_> >& _o_p_e_r_a_t_o_r_=(const _S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +<_B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_> >& _m_a_t)
│ │ │ │ │ +257 {
│ │ │ │ │ +258 if (this->N_ + this->M_ + this->Nnz_!=0)
│ │ │ │ │ +259 free();
│ │ │ │ │ +260
│ │ │ │ │ +261 using _M_a_t_r_i_x = _B_C_R_S_M_a_t_r_i_x_<_B_,_T_A_>;
│ │ │ │ │ +262 this->N_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_r_o_w_d_i_m(_m_a_t);
│ │ │ │ │ +263 this->M_ = _M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_c_o_l_d_i_m(_m_a_t);
│ │ │ │ │ +264 ISTL::Impl::BCCSMatrixInitializer initializer(*this);
│ │ │ │ │ +265
│ │ │ │ │ +266 copyToBCCSMatrix(initializer, _m_a_t);
│ │ │ │ │ +267
│ │ │ │ │ +268 _S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r_<_B_>
│ │ │ │ │ +269_ _:_:_c_r_e_a_t_e(&A, this->N_, this->M_, this->colstart[this->N_],
│ │ │ │ │ +270 this->values,this->rowindex, this->colstart, SLU_NC,
│ │ │ │ │ +271 static_cast(_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_B_>_:_:_t_y_p_e), SLU_GE);
│ │ │ │ │ +272 return *this;
│ │ │ │ │ +273 }
│ │ │ │ │ +274
│ │ │ │ │ +_2_8_1 virtual void _s_e_t_M_a_t_r_i_x(const _M_a_t_r_i_x& _m_a_t, const std::set& mrs)
│ │ │ │ │ +282 {
│ │ │ │ │ +283 if(this->N_+this->M_+this->Nnz_!=0)
│ │ │ │ │ +284 free();
│ │ │ │ │ +285 this->N_=mrs.size()*_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e_>_:_:_r_o_w_d_i_m(*
│ │ │ │ │ +(_m_a_t[0].begin()));
│ │ │ │ │ +286 this->M_=mrs.size()*_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_b_l_o_c_k___t_y_p_e_>_:_:_c_o_l_d_i_m(*
│ │ │ │ │ +(_m_a_t[0].begin()));
│ │ │ │ │ +287 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_M_a_t_r_i_x_> initializer(*this);
│ │ │ │ │ +288
│ │ │ │ │ +289 copyToBCCSMatrix(initializer, ISTL::Impl::MatrixRowSubset<_M_a_t_r_i_x,std::
│ │ │ │ │ +set >(_m_a_t,mrs));
│ │ │ │ │ +290 }
│ │ │ │ │ +291
│ │ │ │ │ +_2_9_3 virtual void _s_e_t_M_a_t_r_i_x(const _M_a_t_r_i_x& _m_a_t)
│ │ │ │ │ +294 {
│ │ │ │ │ +295 this->N_=_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_r_o_w_d_i_m(_m_a_t);
│ │ │ │ │ +296 this->M_=_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_<_M_a_t_r_i_x_>_:_:_c_o_l_d_i_m(_m_a_t);
│ │ │ │ │ +297 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_M_a_t_r_i_x_> initializer(*this);
│ │ │ │ │ +298
│ │ │ │ │ +299 copyToBCCSMatrix(initializer, _m_a_t);
│ │ │ │ │ +300 }
│ │ │ │ │ +301
│ │ │ │ │ +_3_0_3 virtual void _f_r_e_e()
│ │ │ │ │ +304 {
│ │ │ │ │ +305 ISTL::Impl::BCCSMatrix::field_type, int>::free();
│ │ │ │ │ +306 SUPERLU_FREE(A.Store);
│ │ │ │ │ +307 }
│ │ │ │ │ +308 private:
│ │ │ │ │ +309 SuperMatrix A;
│ │ │ │ │ +310 };
│ │ │ │ │ +311
│ │ │ │ │ +312 template
│ │ │ │ │ +_3_1_3 class _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r<_B_C_R_S_M_a_t_r_i_x >
│ │ │ │ │ +314 : public ISTL::Impl::BCCSMatrixInitializer, int>
│ │ │ │ │ +315 {
│ │ │ │ │ +316 template
│ │ │ │ │ +_3_1_7 friend class _O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_I_n_i_t_i_a_l_i_z_e_r;
│ │ │ │ │ +318 public:
│ │ │ │ │ +_3_1_9 typedef _B_C_R_S_M_a_t_r_i_x_<_B_,_A_> _M_a_t_r_i_x;
│ │ │ │ │ +_3_2_0 typedef _D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_M_a_t_r_i_x_> _S_u_p_e_r_L_U_M_a_t_r_i_x;
│ │ │ │ │ +321
│ │ │ │ │ +_3_2_2 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r(_S_u_p_e_r_L_U_M_a_t_r_i_x& lum) : ISTL::Impl::
│ │ │ │ │ +BCCSMatrixInitializer<_B_C_R_S_M_a_t_r_i_x, int>(lum)
│ │ │ │ │ +323 ,slumat(&lum)
│ │ │ │ │ +324 {}
│ │ │ │ │ +325
│ │ │ │ │ +_3_2_6 _S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r() : ISTL::Impl::
│ │ │ │ │ +BCCSMatrixInitializer<_B_C_R_S_M_a_t_r_i_x, int>()
│ │ │ │ │ +327 {}
│ │ │ │ │ +328
│ │ │ │ │ +_3_2_9 virtual void _c_r_e_a_t_e_M_a_t_r_i_x() const
│ │ │ │ │ +330 {
│ │ │ │ │ +331 ISTL::Impl::BCCSMatrixInitializer, int>::createMatrix();
│ │ │ │ │ +332 _S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>
│ │ │ │ │ +333_ _:_:_c_r_e_a_t_e(&slumat->A, slumat->N_, slumat->M_, slumat->colstart[this->cols],
│ │ │ │ │ +334 slumat->values,slumat->rowindex, slumat->colstart, SLU_NC,
│ │ │ │ │ +335 static_cast(_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_t_y_p_e_n_a_m_e_ _M_a_t_r_i_x_:_:_f_i_e_l_d___t_y_p_e_>_:_:_t_y_p_e),
│ │ │ │ │ +SLU_GE);
│ │ │ │ │ +336 }
│ │ │ │ │ +337 private:
│ │ │ │ │ +338 _S_u_p_e_r_L_U_M_a_t_r_i_x* slumat;
│ │ │ │ │ +339 };
│ │ │ │ │ +340}
│ │ │ │ │ +341#endif // HAVE_SUPERLU
│ │ │ │ │ +342#endif
│ │ │ │ │ +_b_c_r_s_m_a_t_r_i_x_._h_h
│ │ │ │ │ +Implementation of the BCRSMatrix class.
│ │ │ │ │ +_s_u_p_e_r_l_u_f_u_n_c_t_i_o_n_s_._h_h
│ │ │ │ │ +_b_c_c_s_m_a_t_r_i_x_i_n_i_t_i_a_l_i_z_e_r_._h_h
│ │ │ │ │ +_b_v_e_c_t_o_r_._h_h
│ │ │ │ │ +This file implements a vector space as a tensor product of a given vector
│ │ │ │ │ +space. The number of compon...
│ │ │ │ │ +_m_a_t
│ │ │ │ │ +Matrix & mat
│ │ │ │ │ +DDeeffiinniittiioonn matrixmatrix.hh:347
│ │ │ │ │ +_s_t_d
│ │ │ │ │ +STL namespace.
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_D_u_n_e_:_:_I_S_T_L_E_r_r_o_r
│ │ │ │ │ -derive error class from the base class in common
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:19
│ │ │ │ │ -_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_E_r_r_o_r
│ │ │ │ │ -Error specific to BCRSMatrix.
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:24
│ │ │ │ │ -_D_u_n_e_:_:_I_m_p_l_i_c_i_t_M_o_d_e_C_o_m_p_r_e_s_s_i_o_n_B_u_f_f_e_r_E_x_h_a_u_s_t_e_d
│ │ │ │ │ -Thrown when the compression buffer used by the implicit BCRSMatrix construction
│ │ │ │ │ -is exhausted.
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:37
│ │ │ │ │ -_D_u_n_e_:_:_S_o_l_v_e_r_A_b_o_r_t
│ │ │ │ │ -Thrown when a solver aborts due to some problem.
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:46
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r
│ │ │ │ │ -Error when performing an operation on a matrix block.
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:52
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r_:_:_c
│ │ │ │ │ -int c
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:54
│ │ │ │ │ -_D_u_n_e_:_:_M_a_t_r_i_x_B_l_o_c_k_E_r_r_o_r_:_:_r
│ │ │ │ │ -int r
│ │ │ │ │ -DDeeffiinniittiioonn istlexception.hh:54
│ │ │ │ │ +_D_u_n_e_:_:_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ +Initializer for SuperLU Matrices representing the subdomains.
│ │ │ │ │ +DDeeffiinniittiioonn overlappingschwarz.hh:47
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_:_:_c_o_l_d_i_m
│ │ │ │ │ +static auto coldim(const M &A)
│ │ │ │ │ +DDeeffiinniittiioonn matrixutils.hh:219
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_D_i_m_e_n_s_i_o_n_:_:_r_o_w_d_i_m
│ │ │ │ │ +static auto rowdim(const M &A)
│ │ │ │ │ +DDeeffiinniittiioonn matrixutils.hh:214
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x
│ │ │ │ │ +A sparse block matrix with compressed row storage.
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:466
│ │ │ │ │ +_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ +A::size_type size_type
│ │ │ │ │ +The type for the index access and the size.
│ │ │ │ │ +DDeeffiinniittiioonn bcrsmatrix.hh:497
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z
│ │ │ │ │ +Sequential overlapping Schwarz preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn overlappingschwarz.hh:755
│ │ │ │ │ +_D_u_n_e_:_:_S_e_q_O_v_e_r_l_a_p_p_i_n_g_S_c_h_w_a_r_z_A_s_s_e_m_b_l_e_r_H_e_l_p_e_r
│ │ │ │ │ +DDeeffiinniittiioonn overlappingschwarz.hh:694
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U
│ │ │ │ │ +SuperLu Solver.
│ │ │ │ │ +DDeeffiinniittiioonn superlu.hh:271
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_C_r_e_a_t_e_S_p_a_r_s_e_C_h_o_o_s_e_r
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:26
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_P_r_i_n_t_e_r
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:30
│ │ │ │ │ +_D_u_n_e_:_:_B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:126
│ │ │ │ │ +_D_u_n_e_:_:_B_a_s_e_G_e_t_S_u_p_e_r_L_U_T_y_p_e_:_:_t_y_p_e
│ │ │ │ │ +static const Dtype_t type
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:127
│ │ │ │ │ +_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:132
│ │ │ │ │ +_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _d_o_u_b_l_e_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ +double float_type
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:144
│ │ │ │ │ +_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _f_l_o_a_t_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ +float float_type
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:151
│ │ │ │ │ +_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _d_o_u_b_l_e_ _>_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ +double float_type
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:158
│ │ │ │ │ +_D_u_n_e_:_:_G_e_t_S_u_p_e_r_L_U_T_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _f_l_o_a_t_ _>_ _>_:_:_f_l_o_a_t___t_y_p_e
│ │ │ │ │ +float float_type
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:165
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +Utility class for converting an ISTL Matrix into a SuperLU Matrix.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:175
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:179
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_f_r_e_e
│ │ │ │ │ +virtual void free()
│ │ │ │ │ +free allocated space.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:303
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ +SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const SuperLUMatrix<
│ │ │ │ │ +BCRSMatrix< B, TA > > &mat)
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:256
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_o_p_e_r_a_t_o_r_=
│ │ │ │ │ +SuperLUMatrix< BCRSMatrix< B, TA > > & operator=(const BCRSMatrix< B, TA >
│ │ │ │ │ +&mat)
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:237
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +SuperLUMatrix(const Matrix &mat)
│ │ │ │ │ +Constructor that initializes the data.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:212
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_s_e_t_M_a_t_r_i_x
│ │ │ │ │ +virtual void setMatrix(const Matrix &mat)
│ │ │ │ │ +Initialize data from given matrix.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:293
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +SuperLUMatrix()
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:215
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_s_i_z_e___t_y_p_e
│ │ │ │ │ +Matrix::size_type size_type
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:206
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_M_a_t_r_i_x
│ │ │ │ │ +BCRSMatrix< B, TA > Matrix
│ │ │ │ │ +The type of the matrix to convert.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:202
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_s_e_t_M_a_t_r_i_x
│ │ │ │ │ +virtual void setMatrix(const Matrix &mat, const std::set< std::size_t > &mrs)
│ │ │ │ │ +Initialize data from a given set of matrix rows and columns.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:281
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _T_A_ _>_ _>_:_:_~_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +virtual ~SuperLUMatrix()
│ │ │ │ │ +Destructor.
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:219
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_S_u_p_e_r_L_U_M_a_t_r_i_x
│ │ │ │ │ +Dune::SuperLUMatrix< Matrix > SuperLUMatrix
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:320
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_M_a_t_r_i_x
│ │ │ │ │ +BCRSMatrix< B, A > Matrix
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:319
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ +SuperMatrixInitializer()
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:326
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_c_r_e_a_t_e_M_a_t_r_i_x
│ │ │ │ │ +virtual void createMatrix() const
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:329
│ │ │ │ │ +_D_u_n_e_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>_:_:_S_u_p_e_r_M_a_t_r_i_x_I_n_i_t_i_a_l_i_z_e_r
│ │ │ │ │ +SuperMatrixInitializer(SuperLUMatrix &lum)
│ │ │ │ │ +DDeeffiinniittiioonn supermatrix.hh:322
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00017.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: multitypeblockmatrix.hh File Reference
│ │ │ │ +dune-istl: gsetc.hh File Reference
│ │ │ │ dune istl
│ │ │ │ +
│ │ │ │ +
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.
│ │ │ │ +More...
│ │ │ │
#include <cmath>
│ │ │ │ +
#include <complex>
│ │ │ │
#include <iostream>
│ │ │ │ -
#include <tuple>
│ │ │ │ +
#include <iomanip>
│ │ │ │ +
#include <string>
│ │ │ │
#include <dune/common/hybridutilities.hh>
│ │ │ │ -
#include "istlexception.hh "
│ │ │ │ -
#include "gsetc.hh "
│ │ │ │ +
#include "multitypeblockvector.hh "
│ │ │ │ +
#include "multitypeblockmatrix.hh "
│ │ │ │ +
#include "istlexception.hh "
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ class Dune::MultiTypeBlockMatrix< FirstRow, Args > A Matrix class to support different block types. More... struct Dune::BL< l > compile-time parameter for block recursion depth More... struct Dune::algmeta_btsolve< I, diag, relax > struct Dune::algmeta_btsolve< 0, withdiag, withrelax > struct Dune::algmeta_btsolve< 0, withdiag, norelax > struct Dune::FieldTraits< MultiTypeBlockMatrix< Rows... > > struct Dune::algmeta_btsolve< 0, nodiag, withrelax > class Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, remain_col > part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types More... struct Dune::algmeta_btsolve< 0, nodiag, norelax > class Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, 0 > struct Dune::algmeta_bdsolve< I, relax > class Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row > solver for MultiTypeBlockVector & MultiTypeBlockMatrix types More... struct Dune::algmeta_bdsolve< 0, withrelax > class Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 > struct Dune::algmeta_bdsolve< 0, norelax > struct std::tuple_element< i, Dune::MultiTypeBlockMatrix< Args... > > Make std::tuple_element work for MultiTypeBlockMatrix. More... struct Dune::algmeta_itsteps< I, M > struct std::tuple_size< Dune::MultiTypeBlockMatrix< Args... > > Make std::tuple_size work for MultiTypeBlockMatrix. More... struct Dune::algmeta_itsteps< 0, M > struct Dune::algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >
│ │ │ │ namespace Dune namespace std STL namespace.
│ │ │ │ template<typename T1 , typename... Args> std::ostream & Dune::operator<< (std::ostream &s, const MultiTypeBlockMatrix < T1, Args... > &m) << operator for a MultiTypeBlockMatrix template<class M , class X , class Y > void Dune::bltsolve (const M &A, X &v, const Y &d) block lower triangular solve template<class M , class X , class Y , class K > void Dune::bltsolve (const M &A, X &v, const Y &d, const K &w) relaxed block lower triangular solve template<class M , class X , class Y > void Dune::ubltsolve (const M &A, X &v, const Y &d) unit block lower triangular solve template<class M , class X , class Y , class K > void Dune::ubltsolve (const M &A, X &v, const Y &d, const K &w) relaxed unit block lower triangular solve template<class M , class X , class Y > void Dune::butsolve (const M &A, X &v, const Y &d) block upper triangular solve template<class M , class X , class Y , class K > void Dune::butsolve (const M &A, X &v, const Y &d, const K &w) relaxed block upper triangular solve template<class M , class X , class Y > void Dune::ubutsolve (const M &A, X &v, const Y &d) unit block upper triangular solve template<class M , class X , class Y , class K > void Dune::ubutsolve (const M &A, X &v, const Y &d, const K &w) relaxed unit block upper triangular solve template<class M , class X , class Y , int l> void Dune::bltsolve (const M &A, X &v, const Y &d, BL < l >) block lower triangular solve template<class M , class X , class Y , class K , int l> void Dune::bltsolve (const M &A, X &v, const Y &d, const K &w, BL < l >) relaxed block lower triangular solve template<class M , class X , class Y , int l> void Dune::ubltsolve (const M &A, X &v, const Y &d, BL < l >) unit block lower triangular solve template<class M , class X , class Y , class K , int l> void Dune::ubltsolve (const M &A, X &v, const Y &d, const K &w, BL < l >) relaxed unit block lower triangular solve template<class M , class X , class Y , int l> void Dune::butsolve (const M &A, X &v, const Y &d, BL < l > bl) block upper triangular solve template<class M , class X , class Y , class K , int l> void Dune::butsolve (const M &A, X &v, const Y &d, const K &w, BL < l > bl) relaxed block upper triangular solve template<class M , class X , class Y , int l> void Dune::ubutsolve (const M &A, X &v, const Y &d, BL < l > bl) unit block upper triangular solve template<class M , class X , class Y , class K , int l> void Dune::ubutsolve (const M &A, X &v, const Y &d, const K &w, BL < l > bl) relaxed unit block upper triangular solve template<class M , class X , class Y > void Dune::bdsolve (const M &A, X &v, const Y &d) block diagonal solve, no relaxation template<class M , class X , class Y , class K > void Dune::bdsolve (const M &A, X &v, const Y &d, const K &w) block diagonal solve, with relaxation template<class M , class X , class Y , int l> void Dune::bdsolve (const M &A, X &v, const Y &d, BL < l >) block diagonal solve, no relaxation template<class M , class X , class Y , class K , int l> void Dune::bdsolve (const M &A, X &v, const Y &d, const K &w, BL < l >) block diagonal solve, with relaxation template<class M , class X , class Y , class K > void Dune::dbgs (const M &A, X &x, const Y &b, const K &w) GS step. template<class M , class X , class Y , class K , int l> void Dune::dbgs (const M &A, X &x, const Y &b, const K &w, BL < l >) GS step. template<class M , class X , class Y , class K > void Dune::bsorf (const M &A, X &x, const Y &b, const K &w) SOR step. template<class M , class X , class Y , class K , int l> void Dune::bsorf (const M &A, X &x, const Y &b, const K &w, BL < l >) SOR step. template<class M , class X , class Y , class K > void Dune::bsorb (const M &A, X &x, const Y &b, const K &w) SSOR step. template<class M , class X , class Y , class K , int l> void Dune::bsorb (const M &A, X &x, const Y &b, const K &w, BL < l >) Backward SOR step. template<class M , class X , class Y , class K > void Dune::dbjac (const M &A, X &x, const Y &b, const K &w) Jacobi step. template<class M , class X , class Y , class K , int l> void Dune::dbjac (const M &A, X &x, const Y &b, const K &w, BL < l >) Jacobi step.
│ │ │ │ -
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.
│ │ │ │ +
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ +#include "_m_u_l_t_i_t_y_p_e_b_l_o_c_k_v_e_c_t_o_r_._h_h"
│ │ │ │ │ +#include "_m_u_l_t_i_t_y_p_e_b_l_o_c_k_m_a_t_r_i_x_._h_h"
│ │ │ │ │ #include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ -#include "_g_s_e_t_c_._h_h"
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ CCllaasssseess
│ │ │ │ │ - class _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x_<_ _F_i_r_s_t_R_o_w_,_ _A_r_g_s_ _>
│ │ │ │ │ - A _M_a_t_r_i_x class to support different block types. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_B_L_<_ _l_ _>
│ │ │ │ │ + compile-time parameter for block recursion depth _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_F_i_e_l_d_T_r_a_i_t_s_<_ _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x_<_ _R_o_w_s_._._._ _>_ _>
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_ _I_,_ _d_i_a_g_,_ _r_e_l_a_x_ _>
│ │ │ │ │
│ │ │ │ │ - class _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x___S_o_l_v_e_r___C_o_l_<_ _I_,_ _c_r_o_w_,_ _c_c_o_l_,_ _r_e_m_a_i_n___c_o_l_ _>
│ │ │ │ │ - part of solvers for _M_u_l_t_i_T_y_p_e_B_l_o_c_k_V_e_c_t_o_r & _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x types
│ │ │ │ │ - _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_ _0_,_ _w_i_t_h_d_i_a_g_,_ _w_i_t_h_r_e_l_a_x_ _>
│ │ │ │ │
│ │ │ │ │ - class _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x___S_o_l_v_e_r___C_o_l_<_ _I_,_ _c_r_o_w_,_ _c_c_o_l_,_ _0_ _>
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_ _0_,_ _w_i_t_h_d_i_a_g_,_ _n_o_r_e_l_a_x_ _>
│ │ │ │ │
│ │ │ │ │ - class _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x___S_o_l_v_e_r_<_ _I_,_ _c_r_o_w_,_ _r_e_m_a_i_n___r_o_w_ _>
│ │ │ │ │ - solver for _M_u_l_t_i_T_y_p_e_B_l_o_c_k_V_e_c_t_o_r & _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x types _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_ _0_,_ _n_o_d_i_a_g_,_ _w_i_t_h_r_e_l_a_x_ _>
│ │ │ │ │
│ │ │ │ │ - class _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x___S_o_l_v_e_r_<_ _I_,_ _c_r_o_w_,_ _0_ _>
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_ _0_,_ _n_o_d_i_a_g_,_ _n_o_r_e_l_a_x_ _>
│ │ │ │ │
│ │ │ │ │ -struct _s_t_d_:_:_t_u_p_l_e___e_l_e_m_e_n_t_<_ _i_,_ _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x_<_ _A_r_g_s_._._._ _>_ _>
│ │ │ │ │ - Make std::tuple_element work for MultiTypeBlockMatrix. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_ _I_,_ _r_e_l_a_x_ _>
│ │ │ │ │
│ │ │ │ │ -struct _s_t_d_:_:_t_u_p_l_e___s_i_z_e_<_ _D_u_n_e_:_:_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x_<_ _A_r_g_s_._._._ _>_ _>
│ │ │ │ │ - Make std::tuple_size work for MultiTypeBlockMatrix. _M_o_r_e_._._.
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_ _0_,_ _w_i_t_h_r_e_l_a_x_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_ _0_,_ _n_o_r_e_l_a_x_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___i_t_s_t_e_p_s_<_ _I_,_ _M_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___i_t_s_t_e_p_s_<_ _0_,_ _M_ _>
│ │ │ │ │ +
│ │ │ │ │ +struct _D_u_n_e_:_:_a_l_g_m_e_t_a___i_t_s_t_e_p_s_<_ _I_,_ _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x_<_ _T_1_,
│ │ │ │ │ + _M_u_l_t_i_T_y_p_e_M_a_t_r_i_x_A_r_g_s_._._._ _>_ _>
│ │ │ │ │
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ -namespace _s_t_d
│ │ │ │ │ - STL namespace.
│ │ │ │ │ +EEnnuummeerraattiioonnss
│ │ │ │ │ +enum _D_u_n_e_:_:_W_i_t_h_D_i_a_g_T_y_p_e { _D_u_n_e_:_:_w_i_t_h_d_i_a_g =1 , _D_u_n_e_:_:_n_o_d_i_a_g =0 }
│ │ │ │ │
│ │ │ │ │ -FFuunnccttiioonnss
│ │ │ │ │ -template
│ │ │ │ │ -std::ostream & _D_u_n_e_:_:_o_p_e_r_a_t_o_r_<_< (std::ostream &s, const _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x<
│ │ │ │ │ - T1, Args... > &m)
│ │ │ │ │ - << operator for a _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x
│ │ │ │ │ +enum _D_u_n_e_:_:_W_i_t_h_R_e_l_a_x_T_y_p_e { _D_u_n_e_:_:_w_i_t_h_r_e_l_a_x =1 , _D_u_n_e_:_:_n_o_r_e_l_a_x =0 }
│ │ │ │ │
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d)
│ │ │ │ │ + block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w)
│ │ │ │ │ + relaxed block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d)
│ │ │ │ │ + unit block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w)
│ │ │ │ │ + relaxed unit block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d)
│ │ │ │ │ + block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w)
│ │ │ │ │ + relaxed block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d)
│ │ │ │ │ + unit block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w)
│ │ │ │ │ + relaxed unit block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d, _B_L< l >)
│ │ │ │ │ + block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w, _B_L< l >)
│ │ │ │ │ + relaxed block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d, _B_L< l >)
│ │ │ │ │ + unit block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_l_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w, _B_L< l >)
│ │ │ │ │ + relaxed unit block lower triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d, _B_L< l > bl)
│ │ │ │ │ + block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w, _B_L< l > bl)
│ │ │ │ │ + relaxed block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d, _B_L< l > bl)
│ │ │ │ │ + unit block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_u_b_u_t_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w, _B_L< l > bl)
│ │ │ │ │ + relaxed unit block upper triangular solve
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_d_s_o_l_v_e (const M &A, X &v, const Y &d)
│ │ │ │ │ + block diagonal solve, no relaxation
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_d_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w)
│ │ │ │ │ + block diagonal solve, with relaxation
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_d_s_o_l_v_e (const M &A, X &v, const Y &d, _B_L< l >)
│ │ │ │ │ + block diagonal solve, no relaxation
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_d_s_o_l_v_e (const M &A, X &v, const Y &d, const K &w, _B_L< l >)
│ │ │ │ │ + block diagonal solve, with relaxation
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_d_b_g_s (const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ + GS step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_d_b_g_s (const M &A, X &x, const Y &b, const K &w, _B_L< l >)
│ │ │ │ │ + GS step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_s_o_r_f (const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ + SOR step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_s_o_r_f (const M &A, X &x, const Y &b, const K &w, _B_L< l >)
│ │ │ │ │ + SOR step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_s_o_r_b (const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ + SSOR step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_b_s_o_r_b (const M &A, X &x, const Y &b, const K &w, _B_L< l >)
│ │ │ │ │ + Backward SOR step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_d_b_j_a_c (const M &A, X &x, const Y &b, const K &w)
│ │ │ │ │ + Jacobi step.
│ │ │ │ │ +
│ │ │ │ │ +template
│ │ │ │ │ +void _D_u_n_e_:_:_d_b_j_a_c (const M &A, X &x, const Y &b, const K &w, _B_L< l >)
│ │ │ │ │ + Jacobi step.
│ │ │ │ │ +
│ │ │ │ │ +********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ +Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ +generic way.
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/libdune-istl-doc/doxygen/a00017_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ dune-istl: multitypeblockmatrix.hh Source File
│ │ │ │ +dune-istl: gsetc.hh Source File
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5 #ifndef DUNE_ISTL_MULTITYPEBLOCKMATRIX_HH
│ │ │ │ -
6 #define DUNE_ISTL_MULTITYPEBLOCKMATRIX_HH
│ │ │ │ +
5 #ifndef DUNE_ISTL_GSETC_HH
│ │ │ │ +
6 #define DUNE_ISTL_GSETC_HH
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
12 #include <dune/common/hybridutilities.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
14 #include <dune/common/hybridutilities.hh>
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
19 template <
typename FirstRow,
typename ... Args>
│ │ │ │ -
20 class MultiTypeBlockMatrix;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
22 template <
int I,
int crow,
int remain_row>
│ │ │ │ -
23 class MultiTypeBlockMatrix_Solver;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
43 template <
typename FirstRow,
typename ... Args>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
45 :
public std::tuple<FirstRow, Args...>
│ │ │ │ -
│ │ │ │ -
47 using ParentType = std::tuple<FirstRow, Args...>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
51 using ParentType::ParentType;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
67 typename FieldTraits<FirstRow>::field_type,
typename FieldTraits<Args>::field_type...>;
│ │ │ │ -
│ │ │ │ -
74 using real_type = Std::detected_t<std::common_type_t,
│ │ │ │ -
75 typename FieldTraits<FirstRow>::real_type,
typename FieldTraits<Args>::real_type...>;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
79 static_assert (
sizeof ...(Args) == 0 or
│ │ │ │ -
80 not (std::is_same_v<field_type, Std::nonesuch> or std::is_same_v<real_type, Std::nonesuch>),
│ │ │ │ -
81 "No std::common_type implemented for the given field_type/real_type of the Args. Please provide an implementation and check that a FieldTraits class is present for your type." );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
86 return 1+
sizeof ...(Args);
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
68 template <
int I, WithDiagType diag, WithRelaxType relax>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
70 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
71 static void bltsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
74 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
75 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
76 typedef typename Y::block_type bblock;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
79 rowiterator endi=A.end();
│ │ │ │ +
80 for (rowiterator i=A.begin(); i!=endi; ++i)
│ │ │ │ +
│ │ │ │ +
82 bblock rhs(d[i.index()]);
│ │ │ │ +
│ │ │ │ +
84 for (j=(*i).begin(); j.index()<i.index(); ++j)
│ │ │ │ +
85 (*j).mmv(v[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
89 template <
class M,
class X,
class Y,
class K>
│ │ │ │
│ │ │ │ -
│ │ │ │ +
90 static void butsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │
│ │ │ │ -
92 return FirstRow::size();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
111 template <
size_t ype index >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
113 operator[] ([[maybe_unused]]
const std::integral_constant< size_type, index > indexVariable)
│ │ │ │ -
114 ->
decltype (std::get<index>(*
this ))
│ │ │ │ +
│ │ │ │ +
93 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
94 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
95 typedef typename Y::block_type bblock;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
98 rowiterator rendi=A.beforeBegin();
│ │ │ │ +
99 for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
│ │ │ │ +
│ │ │ │ +
101 bblock rhs(d[i.index()]);
│ │ │ │ +
│ │ │ │ +
103 for (j=(*i).beforeEnd(); j.index()>i.index(); --j)
│ │ │ │ +
104 (*j).mmv(v[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
113 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
114 static void bltsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │
│ │ │ │ -
116 return std::get<index>(*
this );
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
119 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
120 static void butsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
128 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
129 static void bltsolve (
const M& A, X& v,
const Y& d,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
133 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
134 static void butsolve (
const M& A, X& v,
const Y& d,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
141 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
142 static void bltsolve (
const M& , X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
147 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
148 static void butsolve (
const M& , X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
156 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
157 static void bltsolve (
const M& , X& v,
const Y& d,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
161 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
162 static void butsolve (
const M& , X& v,
const Y& d,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
124 template <
size_t ype index >
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
126 operator[] ([[maybe_unused]]
const std::integral_constant< size_type, index > indexVariable)
const
│ │ │ │ -
127 ->
decltype (std::get<index>(*
this ))
│ │ │ │ -
│ │ │ │ -
129 return std::get<index>(*
this );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
137 using namespace Dune::Hybrid;
│ │ │ │ -
138 auto size = index_constant<1+
sizeof ...(Args)>();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
142 forEach(integralRange(size), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
152 auto size = index_constant<N()>();
│ │ │ │ -
153 Hybrid::forEach(Hybrid::integralRange(size), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
163 auto size = index_constant<N()>();
│ │ │ │ -
164 Hybrid::forEach(Hybrid::integralRange(size), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
179 auto size = index_constant<N()>();
│ │ │ │ -
180 Hybrid::forEach(Hybrid::integralRange(size), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
194 auto size = index_constant<N()>();
│ │ │ │ -
195 Hybrid::forEach(Hybrid::integralRange(size), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
204 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
205 void mv (
const X& x, Y& y)
const {
│ │ │ │ -
206 static_assert (X::size() ==
M (),
"length of x does not match row length" );
│ │ │ │ -
207 static_assert (Y::size() ==
N (),
"length of y does not match row count" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
174 template <
class M,
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
177 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
181 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
182 void bltsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
187 template <
class M,
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
190 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
194 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
195 void ubltsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
201 template <
class M,
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
204 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
208 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
209 void butsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
214 template <
typename X,
typename Y>
│ │ │ │ +
214 template <
class M,
class X,
class Y>
│ │ │ │
│ │ │ │ -
215 void umv (
const X& x, Y& y)
const {
│ │ │ │ -
216 static_assert (X::size() ==
M (),
"length of x does not match row length" );
│ │ │ │ -
217 static_assert (Y::size() ==
N (),
"length of y does not match row count" );
│ │ │ │ -
218 using namespace Dune::Hybrid;
│ │ │ │ -
219 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
220 using namespace Dune::Hybrid;
│ │ │ │ -
221 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
222 (*this)[i][j].umv(x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
217 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
221 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
222 void ubutsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
229 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
230 void mmv (
const X& x, Y& y)
const {
│ │ │ │ -
231 static_assert (X::size() ==
M (),
"length of x does not match row length" );
│ │ │ │ -
232 static_assert (Y::size() ==
N (),
"length of y does not match row count" );
│ │ │ │ -
233 using namespace Dune::Hybrid;
│ │ │ │ -
234 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
235 using namespace Dune::Hybrid;
│ │ │ │ -
236 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
237 (*this)[i][j].mmv(x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
244 template <
typename AlphaType,
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
245 void usmv (
const AlphaType& alpha,
const X& x, Y& y)
const {
│ │ │ │ -
246 static_assert (X::size() ==
M (),
"length of x does not match row length" );
│ │ │ │ -
247 static_assert (Y::size() ==
N (),
"length of y does not match row count" );
│ │ │ │ -
248 using namespace Dune::Hybrid;
│ │ │ │ -
249 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
250 using namespace Dune::Hybrid;
│ │ │ │ -
251 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
252 (*this)[i][j].usmv(alpha, x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
259 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
260 void mtv (
const X& x, Y& y)
const {
│ │ │ │ -
261 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
262 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
269 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
270 void umtv (
const X& x, Y& y)
const {
│ │ │ │ -
271 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
272 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
273 using namespace Dune::Hybrid;
│ │ │ │ -
274 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
275 using namespace Dune::Hybrid;
│ │ │ │ -
276 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
277 (*this)[j][i].umtv(x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
284 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
285 void mmtv (
const X& x, Y& y)
const {
│ │ │ │ -
286 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
287 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
288 using namespace Dune::Hybrid;
│ │ │ │ -
289 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
290 using namespace Dune::Hybrid;
│ │ │ │ -
291 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
292 (*this)[j][i].mmtv(x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
299 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
301 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
302 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
303 using namespace Dune::Hybrid;
│ │ │ │ -
304 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
305 using namespace Dune::Hybrid;
│ │ │ │ -
306 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
307 (*this)[j][i].usmtv(alpha, x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
230 template <
class M,
class X,
class Y,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
233 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
237 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
243 template <
class M,
class X,
class Y,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
246 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
250 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
257 template <
class M,
class X,
class Y,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
260 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
264 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
270 template <
class M,
class X,
class Y,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
273 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
277 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
293 template <
int I, WithRelaxType relax>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
295 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
296 static void bdsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
299 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
300 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
303 rowiterator rendi=A.beforeBegin();
│ │ │ │ +
304 for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
│ │ │ │ +
│ │ │ │ +
306 coliterator ii=(*i).find(i.index());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
314 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
315 void umhv (
const X& x, Y& y)
const {
│ │ │ │ -
316 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
317 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
318 using namespace Dune::Hybrid;
│ │ │ │ -
319 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
320 using namespace Dune::Hybrid;
│ │ │ │ -
321 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
322 (*this)[j][i].umhv(x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
329 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
330 void mmhv (
const X& x, Y& y)
const {
│ │ │ │ -
331 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
332 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
333 using namespace Dune::Hybrid;
│ │ │ │ -
334 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
335 using namespace Dune::Hybrid;
│ │ │ │ -
336 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
337 (*this)[j][i].mmhv(x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
344 template <
typename X,
typename Y>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
346 static_assert (X::size() ==
N (),
"length of x does not match number of rows" );
│ │ │ │ -
347 static_assert (Y::size() ==
M (),
"length of y does not match number of columns" );
│ │ │ │ -
348 using namespace Dune::Hybrid;
│ │ │ │ -
349 forEach(integralRange(Hybrid::size(y)), [&](
auto && i) {
│ │ │ │ -
350 using namespace Dune::Hybrid;
│ │ │ │ -
351 forEach(integralRange(Hybrid::size(x)), [&](
auto && j) {
│ │ │ │ -
352 (*this)[j][i].usmhv(alpha, x[j], y[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
315 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
316 static void bdsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
324 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
325 static void bdsolve (
const M& A, X& v,
const Y& d,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
336 template <
class M,
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
339 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
343 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
344 void bdsolve (
const M& A, X& v,
const Y& d,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
352 template <
class M,
class X,
class Y,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
355 typename X::field_type w=1;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
359 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
365 auto rows = index_constant<N()>();
│ │ │ │ -
366 Hybrid::forEach(Hybrid::integralRange(rows), [&](
auto && i) {
│ │ │ │ -
367 auto cols = index_constant<MultiTypeBlockMatrix<FirstRow, Args...>::M()>();
│ │ │ │ -
368 Hybrid::forEach(Hybrid::integralRange(cols), [&](
auto && j) {
│ │ │ │ -
369 sum += (*this)[i][j].frobenius_norm2();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
374 template <
int I,
typename M>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
377 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
378 static void dbgs (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
380 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
381 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
382 typedef typename Y::block_type bblock;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
387 rowiterator endi=A.end();
│ │ │ │ +
388 for (rowiterator i=A.begin(); i!=endi; ++i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
391 coliterator endj=(*i).end();
│ │ │ │ +
392 coliterator j=(*i).begin();
│ │ │ │ +
393 if constexpr (IsNumber<typename M::block_type>())
│ │ │ │ +
│ │ │ │ +
395 for (; j.index()<i.index(); ++j)
│ │ │ │ +
396 rhs -= (*j) * x[j.index()];
│ │ │ │ +
397 coliterator diag=j++;
│ │ │ │ +
398 for (; j != endj; ++j)
│ │ │ │ +
399 rhs -= (*j) * x[j.index()];
│ │ │ │ +
400 x[i.index()] = rhs / (*diag);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
404 for (; j.index()<i.index(); ++j)
│ │ │ │ +
405 (*j).mmv(x[j.index()],rhs);
│ │ │ │ +
406 coliterator diag=j++;
│ │ │ │ +
407 for (; j != endj; ++j)
│ │ │ │ +
408 (*j).mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
388 auto rows = index_constant<N()>();
│ │ │ │ -
389 Hybrid::forEach(Hybrid::integralRange(rows), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
391 auto cols = index_constant<MultiTypeBlockMatrix<FirstRow, Args...>::M()>();
│ │ │ │ -
392 Hybrid::forEach(Hybrid::integralRange(cols), [&](
auto && j) {
│ │ │ │ -
393 sum += (*this)[i][j].infinity_norm();
│ │ │ │ -
│ │ │ │ -
395 norm = max(sum, norm);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
407 auto rows = index_constant<N()>();
│ │ │ │ -
408 Hybrid::forEach(Hybrid::integralRange(rows), [&](
auto && i) {
│ │ │ │ -
│ │ │ │ -
410 auto cols = index_constant<MultiTypeBlockMatrix<FirstRow, Args...>::M()>();
│ │ │ │ -
411 Hybrid::forEach(Hybrid::integralRange(cols), [&](
auto && j) {
│ │ │ │ -
412 sum += (*this)[i][j].infinity_norm_real();
│ │ │ │ -
│ │ │ │ -
414 norm = max(sum, norm);
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
417 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
418 static void bsorf (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
420 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
421 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
422 typedef typename Y::block_type bblock;
│ │ │ │ +
423 typedef typename X::block_type xblock;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
428 if (A.begin()!=A.end())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
431 rowiterator endi=A.end();
│ │ │ │ +
432 for (rowiterator i=A.begin(); i!=endi; ++i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
435 coliterator endj=(*i).end();
│ │ │ │ +
436 coliterator j=(*i).begin();
│ │ │ │ +
437 if constexpr (IsNumber<typename M::block_type>())
│ │ │ │ +
│ │ │ │ +
439 for (; j.index()<i.index(); ++j)
│ │ │ │ +
440 rhs -= (*j) * x[j.index()];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
443 rhs -= (*j) * x[j.index()];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
449 for (; j.index()<i.index(); ++j)
│ │ │ │ +
450 (*j).mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
453 (*j).mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
455 x[i.index()].axpy(w,v);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
460 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
461 static void bsorb (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
463 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
464 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
465 typedef typename Y::block_type bblock;
│ │ │ │ +
466 typedef typename X::block_type xblock;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
471 if (A.begin()!=A.end())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
474 rowiterator endi=A.beforeBegin();
│ │ │ │ +
475 for (rowiterator i=A.beforeEnd(); i!=endi; --i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
478 coliterator endj=(*i).end();
│ │ │ │ +
479 coliterator j=(*i).begin();
│ │ │ │ +
480 if constexpr (IsNumber<typename M::block_type>())
│ │ │ │ +
│ │ │ │ +
482 for (; j.index()<i.index(); ++j)
│ │ │ │ +
483 rhs -= (*j) * x[j.index()];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
486 rhs -= (*j) * x[j.index()];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
492 for (; j.index()<i.index(); ++j)
│ │ │ │ +
493 j->mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
496 j->mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
498 x[i.index()].axpy(w,v);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
503 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
504 static void dbjac (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
506 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ +
507 typedef typename M::ConstColIterator coliterator;
│ │ │ │ +
508 typedef typename Y::block_type bblock;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
513 rowiterator endi=A.end();
│ │ │ │ +
514 for (rowiterator i=A.begin(); i!=endi; ++i)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
517 coliterator endj=(*i).end();
│ │ │ │ +
518 coliterator j=(*i).begin();
│ │ │ │ +
519 if constexpr (IsNumber<typename M::block_type>())
│ │ │ │ +
│ │ │ │ +
521 for (; j.index()<i.index(); ++j)
│ │ │ │ +
522 rhs -= (*j) * x[j.index()];
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
525 rhs -= (*j) * x[j.index()];
│ │ │ │ +
526 v[i.index()] = rhs / (*diag);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
530 for (; j.index()<i.index(); ++j)
│ │ │ │ +
531 j->mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
534 j->mmv(x[j.index()],rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
544 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
545 static void dbgs (
const M& A, X& x,
const Y& b,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
549 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
550 static void bsorf (
const M& A, X& x,
const Y& b,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
554 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
555 static void bsorb (
const M& A, X& x,
const Y& b,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
559 template <
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
560 static void dbjac (
const M& A, X& x,
const Y& b,
const K& )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
426 template <
typename ... Rows>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
439 template <
typename T1,
typename ... Args>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
441 auto N = index_constant<MultiTypeBlockMatrix<T1,Args...>::N()>();
│ │ │ │ -
442 auto M = index_constant<MultiTypeBlockMatrix<T1,Args...>::M()>();
│ │ │ │ -
443 using namespace Dune::Hybrid;
│ │ │ │ -
444 forEach(integralRange(N), [&](
auto && i) {
│ │ │ │ -
445 using namespace Dune::Hybrid;
│ │ │ │ -
446 forEach(integralRange(M), [&](
auto && j) {
│ │ │ │ -
447 s <<
"\t(" << i <<
", " << j <<
"): \n" << m[i][j];
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
455 template <
int I,
typename M>
│ │ │ │ -
456 struct algmeta_itsteps;
│ │ │ │ -
│ │ │ │ -
464 template <
int I,
int crow,
int ccol,
int remain_col>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
470 template <
typename Trhs,
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
471 static void calc_rhs (
const TMatrix& A, TVector& x, TVector& v, Trhs& b,
const K& w) {
│ │ │ │ -
472 std::get<ccol>( std::get<crow>(A) ).mmv( std::get<ccol>(x), b );
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
477 template <
int I,
int crow,
int ccol>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
480 template <
typename Trhs,
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
481 static void calc_rhs (
const TMatrix&, TVector&, TVector&, Trhs&,
const K&) {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
492 template <
int I,
int crow,
int remain_row>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
499 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
500 static void dbgs (
const TMatrix& A, TVector& x,
const TVector& b,
const K& w) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
507 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
508 static void dbgs (
const TMatrix& A, TVector& x, TVector& v,
const TVector& b,
const K& w) {
│ │ │ │ -
509 auto rhs = std::get<crow> (b);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
514 typename std::remove_cv<
│ │ │ │ -
515 typename std::remove_reference<
│ │ │ │ -
516 decltype (std::get<crow>( std::get<crow>(A)))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
528 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
529 static void bsorf (
const TMatrix& A, TVector& x,
const TVector& b,
const K& w) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
535 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
536 static void bsorf (
const TMatrix& A, TVector& x, TVector& v,
const TVector& b,
const K& w) {
│ │ │ │ -
537 auto rhs = std::get<crow> (b);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
542 typename std::remove_cv<
│ │ │ │ -
543 typename std::remove_reference<
│ │ │ │ -
544 decltype (std::get<crow>( std::get<crow>(A)))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
548 std::get<crow>(x).axpy(w,std::get<crow>(v));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
555 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
556 static void bsorb (
const TMatrix& A, TVector& x,
const TVector& b,
const K& w) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
562 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
563 static void bsorb (
const TMatrix& A, TVector& x, TVector& v,
const TVector& b,
const K& w) {
│ │ │ │ -
564 auto rhs = std::get<crow> (b);
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
569 typename std::remove_cv<
│ │ │ │ -
570 typename std::remove_reference<
│ │ │ │ -
571 decltype (std::get<crow>( std::get<crow>(A)))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
575 std::get<crow>(x).axpy(w,std::get<crow>(v));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
566 template <
int I,
typename T1,
typename ... MultiTypeMatrixArgs>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
569 typename ... MultiTypeVectorArgs,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
583 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
584 static void dbjac (
const TMatrix& A, TVector& x,
const TVector& b,
const K& w) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
590 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
591 static void dbjac (
const TMatrix& A, TVector& x, TVector& v,
const TVector& b,
const K& w) {
│ │ │ │ -
592 auto rhs = std::get<crow> (b);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
597 typename std::remove_cv<
│ │ │ │ -
598 typename std::remove_reference<
│ │ │ │ -
599 decltype (std::get<crow>( std::get<crow>(A)))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
610 template <
int I,
int crow>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
613 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
614 static void dbgs (
const TMatrix&, TVector&, TVector&,
│ │ │ │ -
615 const TVector&,
const K&) {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
617 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
618 static void bsorf (
const TMatrix&, TVector&, TVector&,
│ │ │ │ -
619 const TVector&,
const K&) {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
621 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ +
│ │ │ │ +
581 typename ... MultiTypeVectorArgs,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
593 typename ... MultiTypeVectorArgs,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
605 typename ... MultiTypeVectorArgs,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
621 template <
class M,
class X,
class Y,
class K>
│ │ │ │
│ │ │ │ -
622 static void bsorb (
const TMatrix&, TVector&, TVector&,
│ │ │ │ -
623 const TVector&,
const K&) {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
625 template <
typename TVector,
typename TMatrix,
typename K>
│ │ │ │ -
│ │ │ │ -
626 static void dbjac (
const TMatrix&, TVector&, TVector&,
│ │ │ │ -
627 const TVector&,
const K&) {}
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
638 template <
size_t i,
typename ... Args>
│ │ │ │ -
│ │ │ │ -
639 struct tuple_element<i,
Dune ::MultiTypeBlockMatrix<Args...> >
│ │ │ │ -
│ │ │ │ -
641 using type =
typename std::tuple_element<i, std::tuple<Args...> >::type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
648 template <
typename ... Args>
│ │ │ │ -
│ │ │ │ -
649 struct tuple_size<
Dune ::MultiTypeBlockMatrix<Args...> >
│ │ │ │ -
650 : std::integral_constant<std::size_t, sizeof...(Args)>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.
│ │ │ │ -
typename MultiTypeBlockMatrix< Rows... >::field_type field_type
Definition multitypeblockmatrix.hh:429
│ │ │ │ -
MultiTypeBlockMatrix< FirstRow, Args... > type
Definition multitypeblockmatrix.hh:56
│ │ │ │ +
622 void dbgs (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
627 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
628 void dbgs (
const M& A, X& x,
const Y& b,
const K& w,
BL<l> )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
633 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
634 void bsorf (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
639 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
640 void bsorf (
const M& A, X& x,
const Y& b,
const K& w,
BL<l> )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
645 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
646 void bsorb (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
651 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
652 void bsorb (
const M& A, X& x,
const Y& b,
const K& w,
BL<l> )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
657 template <
class M,
class X,
class Y,
class K>
│ │ │ │ +
│ │ │ │ +
658 void dbjac (
const M& A, X& x,
const Y& b,
const K& w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
663 template <
class M,
class X,
class Y,
class K,
int l>
│ │ │ │ +
│ │ │ │ +
664 void dbjac (
const M& A, X& x,
const Y& b,
const K& w,
BL<l> )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
static void dbjac(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:584
│ │ │ │ -
real_type infinity_norm_real() const
Bastardized version of the infinity-norm / row-sum norm.
Definition multitypeblockmatrix.hh:402
│ │ │ │ -
MultiTypeBlockMatrix & operator+=(const MultiTypeBlockMatrix &b)
Add the entries of another matrix to this one.
Definition multitypeblockmatrix.hh:177
│ │ │ │ -
void mv(const X &x, Y &y) const
y = A x
Definition multitypeblockmatrix.hh:205
│ │ │ │ -
void mmtv(const X &x, Y &y) const
y -= A^T x
Definition multitypeblockmatrix.hh:285
│ │ │ │ -
void mmhv(const X &x, Y &y) const
y -= A^H x
Definition multitypeblockmatrix.hh:330
│ │ │ │ -
Std::detected_t< std::common_type_t, typename FieldTraits< FirstRow >::real_type, typename FieldTraits< Args >::real_type... > real_type
The type used for real values.
Definition multitypeblockmatrix.hh:75
│ │ │ │ -
static void dbgs(const TMatrix &, TVector &, TVector &, const TVector &, const K &)
Definition multitypeblockmatrix.hh:614
│ │ │ │
static void dbgs(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:500
│ │ │ │
static void bsorb(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:556
│ │ │ │ -
void usmhv(const field_type &alpha, const X &x, Y &y) const
y += alpha A^H x
Definition multitypeblockmatrix.hh:345
│ │ │ │ -
void usmv(const AlphaType &alpha, const X &x, Y &y) const
y += alpha A x
Definition multitypeblockmatrix.hh:245
│ │ │ │ -
MultiTypeBlockMatrix & operator/=(const field_type &k)
vector space division by scalar
Definition multitypeblockmatrix.hh:161
│ │ │ │ -
real_type infinity_norm() const
Bastardized version of the infinity-norm / row-sum norm.
Definition multitypeblockmatrix.hh:383
│ │ │ │ -
typename std::tuple_element< i, std::tuple< Args... > >::type type
Definition multitypeblockmatrix.hh:641
│ │ │ │ -
static void dbgs(const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:508
│ │ │ │ -
static void bsorf(const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:536
│ │ │ │ -
void umhv(const X &x, Y &y) const
y += A^H x
Definition multitypeblockmatrix.hh:315
│ │ │ │
static constexpr size_type N()
Return the number of matrix rows.
Definition multitypeblockmatrix.hh:84
│ │ │ │ -
void usmtv(const field_type &alpha, const X &x, Y &y) const
y += alpha A^T x
Definition multitypeblockmatrix.hh:300
│ │ │ │ -
void operator=(const T &newval)
Definition multitypeblockmatrix.hh:136
│ │ │ │ -
static void calc_rhs(const TMatrix &, TVector &, TVector &, Trhs &, const K &)
Definition multitypeblockmatrix.hh:481
│ │ │ │ -
void umv(const X &x, Y &y) const
y += A x
Definition multitypeblockmatrix.hh:215
│ │ │ │ -
static void calc_rhs(const TMatrix &A, TVector &x, TVector &v, Trhs &b, const K &w)
Definition multitypeblockmatrix.hh:471
│ │ │ │
static void bsorf(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:529
│ │ │ │ -
static void dbjac(const TMatrix &, TVector &, TVector &, const TVector &, const K &)
Definition multitypeblockmatrix.hh:626
│ │ │ │ -
std::size_t size_type
Type used for sizes.
Definition multitypeblockmatrix.hh:59
│ │ │ │ -
real_type frobenius_norm2() const
square of frobenius norm, need for block recursion
Definition multitypeblockmatrix.hh:361
│ │ │ │ -
real_type frobenius_norm() const
frobenius norm: sqrt(sum over squared values of entries)
Definition multitypeblockmatrix.hh:377
│ │ │ │ -
static void bsorb(const TMatrix &, TVector &, TVector &, const TVector &, const K &)
Definition multitypeblockmatrix.hh:622
│ │ │ │ -
MultiTypeBlockMatrix & operator-=(const MultiTypeBlockMatrix &b)
Subtract the entries of another matrix from this one.
Definition multitypeblockmatrix.hh:192
│ │ │ │ -
typename MultiTypeBlockMatrix< Rows... >::real_type real_type
Definition multitypeblockmatrix.hh:430
│ │ │ │ -
auto operator[](const std::integral_constant< size_type, index > indexVariable) -> decltype(std::get< index >(*this))
Random-access operator.
Definition multitypeblockmatrix.hh:113
│ │ │ │ -
static void dbjac(const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:591
│ │ │ │ -
static void bsorf(const TMatrix &, TVector &, TVector &, const TVector &, const K &)
Definition multitypeblockmatrix.hh:618
│ │ │ │ -
void mtv(const X &x, Y &y) const
y = A^T x
Definition multitypeblockmatrix.hh:260
│ │ │ │ -
static constexpr size_type M()
Return the number of matrix columns.
Definition multitypeblockmatrix.hh:90
│ │ │ │ -
void mmv(const X &x, Y &y) const
y -= A x
Definition multitypeblockmatrix.hh:230
│ │ │ │ -
Std::detected_t< std::common_type_t, typename FieldTraits< FirstRow >::field_type, typename FieldTraits< Args >::field_type... > field_type
The type used for scalars.
Definition multitypeblockmatrix.hh:67
│ │ │ │ -
void umtv(const X &x, Y &y) const
y += A^T x
Definition multitypeblockmatrix.hh:270
│ │ │ │ -
static void bsorb(const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:563
│ │ │ │ -
MultiTypeBlockMatrix & operator*=(const field_type &k)
vector space multiplication with scalar
Definition multitypeblockmatrix.hh:150
│ │ │ │ -
│ │ │ │ +
void bltsolve(const M &A, X &v, const Y &d)
block lower triangular solve
Definition gsetc.hh:175
│ │ │ │ +
WithDiagType
Definition gsetc.hh:49
│ │ │ │ +
void bsorb(const M &A, X &x, const Y &b, const K &w)
SSOR step.
Definition gsetc.hh:646
│ │ │ │ +
void ubltsolve(const M &A, X &v, const Y &d)
unit block lower triangular solve
Definition gsetc.hh:188
│ │ │ │ +
void dbjac(const M &A, X &x, const Y &b, const K &w)
Jacobi step.
Definition gsetc.hh:658
│ │ │ │ +
void dbgs(const M &A, X &x, const Y &b, const K &w)
GS step.
Definition gsetc.hh:622
│ │ │ │ +
WithRelaxType
Definition gsetc.hh:54
│ │ │ │ +
void bdsolve(const M &A, X &v, const Y &d)
block diagonal solve, no relaxation
Definition gsetc.hh:337
│ │ │ │ +
void butsolve(const M &A, X &v, const Y &d)
block upper triangular solve
Definition gsetc.hh:202
│ │ │ │ +
void bsorf(const M &A, X &x, const Y &b, const K &w)
SOR step.
Definition gsetc.hh:634
│ │ │ │ +
void ubutsolve(const M &A, X &v, const Y &d)
unit block upper triangular solve
Definition gsetc.hh:215
│ │ │ │ +
@ nodiag
Definition gsetc.hh:51
│ │ │ │ +
@ withdiag
Definition gsetc.hh:50
│ │ │ │ +
@ norelax
Definition gsetc.hh:56
│ │ │ │ +
@ withrelax
Definition gsetc.hh:55
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
std::ostream & operator<<(std::ostream &s, const BlockVector< K, A > &v)
Send BlockVector to an output stream.
Definition bvector.hh:583
│ │ │ │ +
A Vector class to support different block types.
Definition multitypeblockvector.hh:59
│ │ │ │
A Matrix class to support different block types.
Definition multitypeblockmatrix.hh:46
│ │ │ │ +
compile-time parameter for block recursion depth
Definition gsetc.hh:45
│ │ │ │ +
@ recursion_level
Definition gsetc.hh:46
│ │ │ │ +
│ │ │ │ +
static void butsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:90
│ │ │ │ +
static void bltsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:71
│ │ │ │ +
static void bltsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:114
│ │ │ │ +
static void butsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:120
│ │ │ │ +
static void bltsolve(const M &A, X &v, const Y &d, const K &)
Definition gsetc.hh:129
│ │ │ │ +
static void butsolve(const M &A, X &v, const Y &d, const K &)
Definition gsetc.hh:134
│ │ │ │ +
static void bltsolve(const M &, X &v, const Y &d, const K &w)
Definition gsetc.hh:142
│ │ │ │ +
static void butsolve(const M &, X &v, const Y &d, const K &w)
Definition gsetc.hh:148
│ │ │ │ +
static void bltsolve(const M &, X &v, const Y &d, const K &)
Definition gsetc.hh:157
│ │ │ │ +
static void butsolve(const M &, X &v, const Y &d, const K &)
Definition gsetc.hh:162
│ │ │ │ +
│ │ │ │ +
static void bdsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:296
│ │ │ │ +
static void bdsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:316
│ │ │ │ +
static void bdsolve(const M &A, X &v, const Y &d, const K &)
Definition gsetc.hh:325
│ │ │ │ +
│ │ │ │
static void bsorb(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:461
│ │ │ │
static void bsorf(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:418
│ │ │ │
static void dbjac(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:504
│ │ │ │
static void dbgs(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:378
│ │ │ │ -
solver for MultiTypeBlockVector & MultiTypeBlockMatrix types
Definition multitypeblockmatrix.hh:493
│ │ │ │ -
part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types
Definition multitypeblockmatrix.hh:465
│ │ │ │ +
static void dbgs(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:545
│ │ │ │ +
static void dbjac(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:560
│ │ │ │ +
static void bsorf(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:550
│ │ │ │ +
static void bsorb(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:555
│ │ │ │ +
static void dbgs(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:571
│ │ │ │ +
static void dbjac(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:608
│ │ │ │ +
static void bsorf(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:583
│ │ │ │ +
static void bsorb(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:595
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,781 +1,832 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -multitypeblockmatrix.hh
│ │ │ │ │ +gsetc.hh
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file
│ │ │ │ │ LICENSE.md in module root
│ │ │ │ │ 2// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
│ │ │ │ │ 3// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
│ │ │ │ │ 4// vi: set et ts=4 sw=2 sts=2:
│ │ │ │ │ -5#ifndef DUNE_ISTL_MULTITYPEBLOCKMATRIX_HH
│ │ │ │ │ -6#define DUNE_ISTL_MULTITYPEBLOCKMATRIX_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_GSETC_HH
│ │ │ │ │ +6#define DUNE_ISTL_GSETC_HH
│ │ │ │ │ 7
│ │ │ │ │ 8#include
│ │ │ │ │ -9#include
│ │ │ │ │ -10#include
│ │ │ │ │ -11
│ │ │ │ │ -12#include
│ │ │ │ │ +9#include
│ │ │ │ │ +10#include
│ │ │ │ │ +11#include
│ │ │ │ │ +12#include
│ │ │ │ │ 13
│ │ │ │ │ -14#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ +14#include
│ │ │ │ │ 15
│ │ │ │ │ -16// forward declaration
│ │ │ │ │ -17namespace _D_u_n_e
│ │ │ │ │ -18{
│ │ │ │ │ -19 template
│ │ │ │ │ -20 class MultiTypeBlockMatrix;
│ │ │ │ │ +16#include "_m_u_l_t_i_t_y_p_e_b_l_o_c_k_v_e_c_t_o_r_._h_h"
│ │ │ │ │ +17#include "_m_u_l_t_i_t_y_p_e_b_l_o_c_k_m_a_t_r_i_x_._h_h"
│ │ │ │ │ +18
│ │ │ │ │ +19#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ +20
│ │ │ │ │ 21
│ │ │ │ │ -22 template
│ │ │ │ │ -23 class MultiTypeBlockMatrix_Solver;
│ │ │ │ │ -24}
│ │ │ │ │ -25
│ │ │ │ │ -26#include "_g_s_e_t_c_._h_h"
│ │ │ │ │ -27
│ │ │ │ │ -28namespace _D_u_n_e {
│ │ │ │ │ -29
│ │ │ │ │ -43 template
│ │ │ │ │ -_4_4 class _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x
│ │ │ │ │ -45 : public std::tuple
│ │ │ │ │ -46 {
│ │ │ │ │ -47 using ParentType = std::tuple;
│ │ │ │ │ -48 public:
│ │ │ │ │ -49
│ │ │ │ │ -51 using ParentType::ParentType;
│ │ │ │ │ -52
│ │ │ │ │ -_5_6 typedef _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x _t_y_p_e;
│ │ │ │ │ -57
│ │ │ │ │ -_5_9 using _s_i_z_e___t_y_p_e = std::size_t;
│ │ │ │ │ -60
│ │ │ │ │ -_6_6 using _f_i_e_l_d___t_y_p_e = Std::detected_t::field_type, typename FieldTraits::
│ │ │ │ │ -field_type...>;
│ │ │ │ │ -68
│ │ │ │ │ -_7_4 using _r_e_a_l___t_y_p_e = Std::detected_t::real_type, typename FieldTraits::
│ │ │ │ │ -real_type...>;
│ │ │ │ │ -76
│ │ │ │ │ -77 // make sure that we have an std::common_type: using an assertion produces a
│ │ │ │ │ -more readable error message
│ │ │ │ │ -78 // than a compiler template instantiation error
│ │ │ │ │ -79 static_assert ( sizeof...(Args) == 0 or
│ │ │ │ │ -80 not (std::is_same_v or std::is_same_v),
│ │ │ │ │ -81 "No std::common_type implemented for the given field_type/real_type of the
│ │ │ │ │ -Args. Please provide an implementation and check that a FieldTraits class is
│ │ │ │ │ -present for your type.");
│ │ │ │ │ -82
│ │ │ │ │ -_8_4 static constexpr _s_i_z_e___t_y_p_e _N()
│ │ │ │ │ -85 {
│ │ │ │ │ -86 return 1+sizeof...(Args);
│ │ │ │ │ +27namespace _D_u_n_e {
│ │ │ │ │ +28
│ │ │ │ │ +39 //============================================================
│ │ │ │ │ +40 // parameter types
│ │ │ │ │ +41 //============================================================
│ │ │ │ │ +42
│ │ │ │ │ +44 template
│ │ │ │ │ +_4_5 struct _B_L {
│ │ │ │ │ +_4_6 enum {_r_e_c_u_r_s_i_o_n___l_e_v_e_l = l};
│ │ │ │ │ +47 };
│ │ │ │ │ +48
│ │ │ │ │ +_4_9 enum _W_i_t_h_D_i_a_g_T_y_p_e {
│ │ │ │ │ +_5_0 _w_i_t_h_d_i_a_g=1,
│ │ │ │ │ +51 _n_o_d_i_a_g=0
│ │ │ │ │ +_5_2 };
│ │ │ │ │ +53
│ │ │ │ │ +_5_4 enum _W_i_t_h_R_e_l_a_x_T_y_p_e {
│ │ │ │ │ +_5_5 _w_i_t_h_r_e_l_a_x=1,
│ │ │ │ │ +56 _n_o_r_e_l_a_x=0
│ │ │ │ │ +_5_7 };
│ │ │ │ │ +58
│ │ │ │ │ +59 //============================================================
│ │ │ │ │ +60 // generic triangular solves
│ │ │ │ │ +61 // consider block decomposition A = L + D + U
│ │ │ │ │ +62 // we can invert L, L+D, U, U+D
│ │ │ │ │ +63 // we can apply relaxation or not
│ │ │ │ │ +64 // we can recurse over a fixed number of levels
│ │ │ │ │ +65 //============================================================
│ │ │ │ │ +66
│ │ │ │ │ +67 // template meta program for triangular solves
│ │ │ │ │ +68 template
│ │ │ │ │ +_6_9 struct _a_l_g_m_e_t_a___b_t_s_o_l_v_e {
│ │ │ │ │ +70 template
│ │ │ │ │ +_7_1 static void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +72 {
│ │ │ │ │ +73 // iterator types
│ │ │ │ │ +74 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ │ +75 typedef typename M::ConstColIterator coliterator;
│ │ │ │ │ +76 typedef typename Y::block_type bblock;
│ │ │ │ │ +77
│ │ │ │ │ +78 // local solve at each block and immediate update
│ │ │ │ │ +79 rowiterator endi=A.end();
│ │ │ │ │ +80 for (rowiterator i=A.begin(); i!=endi; ++i)
│ │ │ │ │ +81 {
│ │ │ │ │ +82 bblock rhs(d[i.index()]);
│ │ │ │ │ +83 coliterator j;
│ │ │ │ │ +84 for (j=(*i).begin(); j.index()_:_:_b_l_t_s_o_l_v_e(*j,v[i.index()],rhs,w);
│ │ │ │ │ 87 }
│ │ │ │ │ -88
│ │ │ │ │ -_9_0 static constexpr _s_i_z_e___t_y_p_e _M()
│ │ │ │ │ +88 }
│ │ │ │ │ +89 template
│ │ │ │ │ +_9_0 static void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ 91 {
│ │ │ │ │ -92 return FirstRow::size();
│ │ │ │ │ -93 }
│ │ │ │ │ -94
│ │ │ │ │ -111 template< size_type index >
│ │ │ │ │ -112 auto
│ │ │ │ │ -_1_1_3 _o_p_e_r_a_t_o_r_[_]_ ([[maybe_unused]] const std::integral_constant< size_type, index
│ │ │ │ │ -> indexVariable)
│ │ │ │ │ -114 -> decltype(std::get(*this))
│ │ │ │ │ +92 // iterator types
│ │ │ │ │ +93 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ │ +94 typedef typename M::ConstColIterator coliterator;
│ │ │ │ │ +95 typedef typename Y::block_type bblock;
│ │ │ │ │ +96
│ │ │ │ │ +97 // local solve at each block and immediate update
│ │ │ │ │ +98 rowiterator rendi=A.beforeBegin();
│ │ │ │ │ +99 for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
│ │ │ │ │ +100 {
│ │ │ │ │ +101 bblock rhs(d[i.index()]);
│ │ │ │ │ +102 coliterator j;
│ │ │ │ │ +103 for (j=(*i).beforeEnd(); j.index()>i.index(); --j)
│ │ │ │ │ +104 (*j).mmv(v[j.index()],rhs);
│ │ │ │ │ +105 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_I_-_1_,_d_i_a_g_,_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(*j,v[i.index()],rhs,w);
│ │ │ │ │ +106 }
│ │ │ │ │ +107 }
│ │ │ │ │ +108 };
│ │ │ │ │ +109
│ │ │ │ │ +110 // recursion end ...
│ │ │ │ │ +111 template<>
│ │ │ │ │ +_1_1_2 struct _a_l_g_m_e_t_a___b_t_s_o_l_v_e<0,_w_i_t_h_d_i_a_g,_w_i_t_h_r_e_l_a_x> {
│ │ │ │ │ +113 template
│ │ │ │ │ +_1_1_4 static void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ 115 {
│ │ │ │ │ -116 return std::get(*this);
│ │ │ │ │ -117 }
│ │ │ │ │ -118
│ │ │ │ │ -124 template< size_type index >
│ │ │ │ │ -125 auto
│ │ │ │ │ -_1_2_6 _o_p_e_r_a_t_o_r_[_]_ ([[maybe_unused]] const std::integral_constant< size_type, index
│ │ │ │ │ -> indexVariable) const
│ │ │ │ │ -127 -> decltype(std::get(*this))
│ │ │ │ │ -128 {
│ │ │ │ │ -129 return std::get(*this);
│ │ │ │ │ -130 }
│ │ │ │ │ -131
│ │ │ │ │ -135 template
│ │ │ │ │ -_1_3_6 void _o_p_e_r_a_t_o_r_=_ (const T& newval) {
│ │ │ │ │ -137 using namespace Dune::Hybrid;
│ │ │ │ │ -138 auto size = index_constant<1+sizeof...(Args)>();
│ │ │ │ │ -139 // Since Dune::Hybrid::size(MultiTypeBlockMatrix) is not implemented,
│ │ │ │ │ -140 // we cannot use a plain forEach(*this, ...). This could be achieved,
│ │ │ │ │ -141 // e.g., by implementing a static size() method.
│ │ │ │ │ -142 forEach(integralRange(size), [&](auto&& i) {
│ │ │ │ │ -143 (*this)[i] = newval;
│ │ │ │ │ -144 });
│ │ │ │ │ -145 }
│ │ │ │ │ -146
│ │ │ │ │ -147 //===== vector space arithmetic
│ │ │ │ │ -148
│ │ │ │ │ -_1_5_0 _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_*_=_ (const _f_i_e_l_d___t_y_p_e& k)
│ │ │ │ │ -151 {
│ │ │ │ │ -152 auto size = index_constant();
│ │ │ │ │ -153 Hybrid::forEach(Hybrid::integralRange(size), [&](auto&& i) {
│ │ │ │ │ -154 (*this)[i] *= k;
│ │ │ │ │ -155 });
│ │ │ │ │ -156
│ │ │ │ │ -157 return *this;
│ │ │ │ │ -158 }
│ │ │ │ │ -159
│ │ │ │ │ -_1_6_1 _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_/_=_ (const _f_i_e_l_d___t_y_p_e& k)
│ │ │ │ │ -162 {
│ │ │ │ │ -163 auto size = index_constant();
│ │ │ │ │ -164 Hybrid::forEach(Hybrid::integralRange(size), [&](auto&& i) {
│ │ │ │ │ -165 (*this)[i] /= k;
│ │ │ │ │ -166 });
│ │ │ │ │ +116 A.solve(v,d);
│ │ │ │ │ +117 v *= w;
│ │ │ │ │ +118 }
│ │ │ │ │ +119 template
│ │ │ │ │ +_1_2_0 static void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +121 {
│ │ │ │ │ +122 A.solve(v,d);
│ │ │ │ │ +123 v *= w;
│ │ │ │ │ +124 }
│ │ │ │ │ +125 };
│ │ │ │ │ +126 template<>
│ │ │ │ │ +_1_2_7 struct _a_l_g_m_e_t_a___b_t_s_o_l_v_e<0,_w_i_t_h_d_i_a_g,_n_o_r_e_l_a_x> {
│ │ │ │ │ +128 template
│ │ │ │ │ +_1_2_9 static void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& /*w*/)
│ │ │ │ │ +130 {
│ │ │ │ │ +131 A.solve(v,d);
│ │ │ │ │ +132 }
│ │ │ │ │ +133 template
│ │ │ │ │ +_1_3_4 static void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& /*w*/)
│ │ │ │ │ +135 {
│ │ │ │ │ +136 A.solve(v,d);
│ │ │ │ │ +137 }
│ │ │ │ │ +138 };
│ │ │ │ │ +139 template<>
│ │ │ │ │ +_1_4_0 struct _a_l_g_m_e_t_a___b_t_s_o_l_v_e<0,_n_o_d_i_a_g,_w_i_t_h_r_e_l_a_x> {
│ │ │ │ │ +141 template
│ │ │ │ │ +_1_4_2 static void _b_l_t_s_o_l_v_e (const M& /*A*/, X& v, const Y& d, const K& w)
│ │ │ │ │ +143 {
│ │ │ │ │ +144 v = d;
│ │ │ │ │ +145 v *= w;
│ │ │ │ │ +146 }
│ │ │ │ │ +147 template
│ │ │ │ │ +_1_4_8 static void _b_u_t_s_o_l_v_e (const M& /*A*/, X& v, const Y& d, const K& w)
│ │ │ │ │ +149 {
│ │ │ │ │ +150 v = d;
│ │ │ │ │ +151 v *= w;
│ │ │ │ │ +152 }
│ │ │ │ │ +153 };
│ │ │ │ │ +154 template<>
│ │ │ │ │ +_1_5_5 struct _a_l_g_m_e_t_a___b_t_s_o_l_v_e<0,_n_o_d_i_a_g,_n_o_r_e_l_a_x> {
│ │ │ │ │ +156 template
│ │ │ │ │ +_1_5_7 static void _b_l_t_s_o_l_v_e (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
│ │ │ │ │ +158 {
│ │ │ │ │ +159 v = d;
│ │ │ │ │ +160 }
│ │ │ │ │ +161 template
│ │ │ │ │ +_1_6_2 static void _b_u_t_s_o_l_v_e (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
│ │ │ │ │ +163 {
│ │ │ │ │ +164 v = d;
│ │ │ │ │ +165 }
│ │ │ │ │ +166 };
│ │ │ │ │ 167
│ │ │ │ │ -168 return *this;
│ │ │ │ │ -169 }
│ │ │ │ │ +168
│ │ │ │ │ +169 // user calls
│ │ │ │ │ 170
│ │ │ │ │ -171
│ │ │ │ │ -_1_7_7 _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_+_=_ (const _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x& b)
│ │ │ │ │ -178 {
│ │ │ │ │ -179 auto size = index_constant();
│ │ │ │ │ -180 Hybrid::forEach(Hybrid::integralRange(size), [&](auto&& i) {
│ │ │ │ │ -181 (*this)[i] += b[i];
│ │ │ │ │ -182 });
│ │ │ │ │ -183
│ │ │ │ │ -184 return *this;
│ │ │ │ │ +171 // default block recursion level = 1
│ │ │ │ │ +172
│ │ │ │ │ +174 template
│ │ │ │ │ +_1_7_5 void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d)
│ │ │ │ │ +176 {
│ │ │ │ │ +177 typename X::field_type w=1;
│ │ │ │ │ +178 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_w_i_t_h_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +179 }
│ │ │ │ │ +181 template
│ │ │ │ │ +_1_8_2 void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +183 {
│ │ │ │ │ +184 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_w_i_t_h_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ 185 }
│ │ │ │ │ -186
│ │ │ │ │ -_1_9_2 _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x& _o_p_e_r_a_t_o_r_-_=_ (const _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x& b)
│ │ │ │ │ -193 {
│ │ │ │ │ -194 auto size = index_constant();
│ │ │ │ │ -195 Hybrid::forEach(Hybrid::integralRange(size), [&](auto&& i) {
│ │ │ │ │ -196 (*this)[i] -= b[i];
│ │ │ │ │ -197 });
│ │ │ │ │ -198
│ │ │ │ │ -199 return *this;
│ │ │ │ │ -200 }
│ │ │ │ │ -201
│ │ │ │ │ -204 template
│ │ │ │ │ -_2_0_5 void _m_v (const X& x, Y& y) const {
│ │ │ │ │ -206 static_assert(X::size() == _M(), "length of x does not match row length");
│ │ │ │ │ -207 static_assert(Y::size() == _N(), "length of y does not match row count");
│ │ │ │ │ -208 y = 0; //reset y (for mv uses umv)
│ │ │ │ │ -209 _u_m_v(x,y);
│ │ │ │ │ -210 }
│ │ │ │ │ -211
│ │ │ │ │ -214 template
│ │ │ │ │ -_2_1_5 void _u_m_v (const X& x, Y& y) const {
│ │ │ │ │ -216 static_assert(X::size() == _M(), "length of x does not match row length");
│ │ │ │ │ -217 static_assert(Y::size() == _N(), "length of y does not match row count");
│ │ │ │ │ -218 using namespace Dune::Hybrid;
│ │ │ │ │ -219 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -220 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -221 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -222 (*this)[i][j].umv(x[j], y[i]);
│ │ │ │ │ -223 });
│ │ │ │ │ -224 });
│ │ │ │ │ +187 template
│ │ │ │ │ +_1_8_8 void _u_b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d)
│ │ │ │ │ +189 {
│ │ │ │ │ +190 typename X::field_type w=1;
│ │ │ │ │ +191 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_n_o_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +192 }
│ │ │ │ │ +194 template
│ │ │ │ │ +_1_9_5 void _u_b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +196 {
│ │ │ │ │ +197 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_n_o_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +198 }
│ │ │ │ │ +199
│ │ │ │ │ +201 template
│ │ │ │ │ +_2_0_2 void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d)
│ │ │ │ │ +203 {
│ │ │ │ │ +204 typename X::field_type w=1;
│ │ │ │ │ +205 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_w_i_t_h_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +206 }
│ │ │ │ │ +208 template
│ │ │ │ │ +_2_0_9 void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +210 {
│ │ │ │ │ +211 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_w_i_t_h_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +212 }
│ │ │ │ │ +214 template
│ │ │ │ │ +_2_1_5 void _u_b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d)
│ │ │ │ │ +216 {
│ │ │ │ │ +217 typename X::field_type w=1;
│ │ │ │ │ +218 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_n_o_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +219 }
│ │ │ │ │ +221 template
│ │ │ │ │ +_2_2_2 void _u_b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +223 {
│ │ │ │ │ +224 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_1_,_n_o_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ 225 }
│ │ │ │ │ 226
│ │ │ │ │ -229 template
│ │ │ │ │ -_2_3_0 void _m_m_v (const X& x, Y& y) const {
│ │ │ │ │ -231 static_assert(X::size() == _M(), "length of x does not match row length");
│ │ │ │ │ -232 static_assert(Y::size() == _N(), "length of y does not match row count");
│ │ │ │ │ -233 using namespace Dune::Hybrid;
│ │ │ │ │ -234 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -235 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -236 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -237 (*this)[i][j].mmv(x[j], y[i]);
│ │ │ │ │ -238 });
│ │ │ │ │ -239 });
│ │ │ │ │ -240 }
│ │ │ │ │ -241
│ │ │ │ │ -244 template
│ │ │ │ │ -_2_4_5 void _u_s_m_v (const AlphaType& alpha, const X& x, Y& y) const {
│ │ │ │ │ -246 static_assert(X::size() == _M(), "length of x does not match row length");
│ │ │ │ │ -247 static_assert(Y::size() == _N(), "length of y does not match row count");
│ │ │ │ │ -248 using namespace Dune::Hybrid;
│ │ │ │ │ -249 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -250 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -251 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -252 (*this)[i][j].usmv(alpha, x[j], y[i]);
│ │ │ │ │ -253 });
│ │ │ │ │ -254 });
│ │ │ │ │ -255 }
│ │ │ │ │ -256
│ │ │ │ │ -259 template
│ │ │ │ │ -_2_6_0 void _m_t_v (const X& x, Y& y) const {
│ │ │ │ │ -261 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -262 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -263 y = 0;
│ │ │ │ │ -264 _u_m_t_v(x,y);
│ │ │ │ │ -265 }
│ │ │ │ │ -266
│ │ │ │ │ -269 template
│ │ │ │ │ -_2_7_0 void _u_m_t_v (const X& x, Y& y) const {
│ │ │ │ │ -271 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -272 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -273 using namespace Dune::Hybrid;
│ │ │ │ │ -274 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -275 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -276 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -277 (*this)[j][i].umtv(x[j], y[i]);
│ │ │ │ │ -278 });
│ │ │ │ │ -279 });
│ │ │ │ │ -280 }
│ │ │ │ │ -281
│ │ │ │ │ -284 template
│ │ │ │ │ -_2_8_5 void _m_m_t_v (const X& x, Y& y) const {
│ │ │ │ │ -286 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -287 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -288 using namespace Dune::Hybrid;
│ │ │ │ │ -289 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -290 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -291 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -292 (*this)[j][i].mmtv(x[j], y[i]);
│ │ │ │ │ -293 });
│ │ │ │ │ -294 });
│ │ │ │ │ -295 }
│ │ │ │ │ -296
│ │ │ │ │ -299 template
│ │ │ │ │ -_3_0_0 void _u_s_m_t_v (const _f_i_e_l_d___t_y_p_e& alpha, const X& x, Y& y) const {
│ │ │ │ │ -301 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -302 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -303 using namespace Dune::Hybrid;
│ │ │ │ │ -304 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -305 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -306 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -307 (*this)[j][i].usmtv(alpha, x[j], y[i]);
│ │ │ │ │ -308 });
│ │ │ │ │ -309 });
│ │ │ │ │ -310 }
│ │ │ │ │ +227 // general block recursion level >= 0
│ │ │ │ │ +228
│ │ │ │ │ +230 template
│ │ │ │ │ +_2_3_1 void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, _B_L_<_l_> /*bl*/)
│ │ │ │ │ +232 {
│ │ │ │ │ +233 typename X::field_type w=1;
│ │ │ │ │ +234 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_w_i_t_h_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +235 }
│ │ │ │ │ +237 template
│ │ │ │ │ +_2_3_8 void _b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w, _B_L_<_l_> /*bl*/)
│ │ │ │ │ +239 {
│ │ │ │ │ +240 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_w_i_t_h_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +241 }
│ │ │ │ │ +243 template
│ │ │ │ │ +_2_4_4 void _u_b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, _B_L_<_l_> /*bl*/)
│ │ │ │ │ +245 {
│ │ │ │ │ +246 typename X::field_type w=1;
│ │ │ │ │ +247 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_n_o_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +248 }
│ │ │ │ │ +250 template
│ │ │ │ │ +_2_5_1 void _u_b_l_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w, _B_L_<_l_> /*bl*/)
│ │ │ │ │ +252 {
│ │ │ │ │ +253 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_n_o_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_l_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +254 }
│ │ │ │ │ +255
│ │ │ │ │ +257 template
│ │ │ │ │ +_2_5_8 void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, _B_L_<_l_> bl)
│ │ │ │ │ +259 {
│ │ │ │ │ +260 typename X::field_type w=1;
│ │ │ │ │ +261 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_w_i_t_h_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +262 }
│ │ │ │ │ +264 template
│ │ │ │ │ +_2_6_5 void _b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w, _B_L_<_l_> bl)
│ │ │ │ │ +266 {
│ │ │ │ │ +267 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_w_i_t_h_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +268 }
│ │ │ │ │ +270 template
│ │ │ │ │ +_2_7_1 void _u_b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, _B_L_<_l_> bl)
│ │ │ │ │ +272 {
│ │ │ │ │ +273 typename X::field_type w=1;
│ │ │ │ │ +274 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_n_o_d_i_a_g_,_n_o_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +275 }
│ │ │ │ │ +277 template
│ │ │ │ │ +_2_7_8 void _u_b_u_t_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w, _B_L_<_l_> bl)
│ │ │ │ │ +279 {
│ │ │ │ │ +280 _a_l_g_m_e_t_a___b_t_s_o_l_v_e_<_l_,_n_o_d_i_a_g_,_w_i_t_h_r_e_l_a_x_>_:_:_b_u_t_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +281 }
│ │ │ │ │ +282
│ │ │ │ │ +283
│ │ │ │ │ +284
│ │ │ │ │ +285 //============================================================
│ │ │ │ │ +286 // generic block diagonal solves
│ │ │ │ │ +287 // consider block decomposition A = L + D + U
│ │ │ │ │ +288 // we can apply relaxation or not
│ │ │ │ │ +289 // we can recurse over a fixed number of levels
│ │ │ │ │ +290 //============================================================
│ │ │ │ │ +291
│ │ │ │ │ +292 // template meta program for diagonal solves
│ │ │ │ │ +293 template
│ │ │ │ │ +_2_9_4 struct _a_l_g_m_e_t_a___b_d_s_o_l_v_e {
│ │ │ │ │ +295 template
│ │ │ │ │ +_2_9_6 static void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +297 {
│ │ │ │ │ +298 // iterator types
│ │ │ │ │ +299 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ │ +300 typedef typename M::ConstColIterator coliterator;
│ │ │ │ │ +301
│ │ │ │ │ +302 // local solve at each block and immediate update
│ │ │ │ │ +303 rowiterator rendi=A.beforeBegin();
│ │ │ │ │ +304 for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
│ │ │ │ │ +305 {
│ │ │ │ │ +306 coliterator ii=(*i).find(i.index());
│ │ │ │ │ +307 _a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_I_-_1_,_r_e_l_a_x_>_:_:_b_d_s_o_l_v_e(*ii,v[i.index()],d[i.index()],w);
│ │ │ │ │ +308 }
│ │ │ │ │ +309 }
│ │ │ │ │ +310 };
│ │ │ │ │ 311
│ │ │ │ │ -314 template
│ │ │ │ │ -_3_1_5 void _u_m_h_v (const X& x, Y& y) const {
│ │ │ │ │ -316 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -317 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -318 using namespace Dune::Hybrid;
│ │ │ │ │ -319 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -320 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -321 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -322 (*this)[j][i].umhv(x[j], y[i]);
│ │ │ │ │ -323 });
│ │ │ │ │ -324 });
│ │ │ │ │ -325 }
│ │ │ │ │ -326
│ │ │ │ │ -329 template
│ │ │ │ │ -_3_3_0 void _m_m_h_v (const X& x, Y& y) const {
│ │ │ │ │ -331 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -332 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -333 using namespace Dune::Hybrid;
│ │ │ │ │ -334 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -335 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -336 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -337 (*this)[j][i].mmhv(x[j], y[i]);
│ │ │ │ │ -338 });
│ │ │ │ │ -339 });
│ │ │ │ │ -340 }
│ │ │ │ │ -341
│ │ │ │ │ -344 template
│ │ │ │ │ -_3_4_5 void _u_s_m_h_v (const _f_i_e_l_d___t_y_p_e& alpha, const X& x, Y& y) const {
│ │ │ │ │ -346 static_assert(X::size() == _N(), "length of x does not match number of
│ │ │ │ │ -rows");
│ │ │ │ │ -347 static_assert(Y::size() == _M(), "length of y does not match number of
│ │ │ │ │ -columns");
│ │ │ │ │ -348 using namespace Dune::Hybrid;
│ │ │ │ │ -349 forEach(integralRange(Hybrid::size(y)), [&](auto&& i) {
│ │ │ │ │ -350 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -351 forEach(integralRange(Hybrid::size(x)), [&](auto&& j) {
│ │ │ │ │ -352 (*this)[j][i].usmhv(alpha, x[j], y[i]);
│ │ │ │ │ -353 });
│ │ │ │ │ -354 });
│ │ │ │ │ -355 }
│ │ │ │ │ -356
│ │ │ │ │ -357
│ │ │ │ │ -358 //===== norms
│ │ │ │ │ -359
│ │ │ │ │ -_3_6_1 _r_e_a_l___t_y_p_e _f_r_o_b_e_n_i_u_s___n_o_r_m_2 () const
│ │ │ │ │ -362 {
│ │ │ │ │ -363 _r_e_a_l___t_y_p_e sum=0;
│ │ │ │ │ +312 // recursion end ...
│ │ │ │ │ +313 template<>
│ │ │ │ │ +_3_1_4 struct _a_l_g_m_e_t_a___b_d_s_o_l_v_e<0,_w_i_t_h_r_e_l_a_x> {
│ │ │ │ │ +315 template
│ │ │ │ │ +_3_1_6 static void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +317 {
│ │ │ │ │ +318 A.solve(v,d);
│ │ │ │ │ +319 v *= w;
│ │ │ │ │ +320 }
│ │ │ │ │ +321 };
│ │ │ │ │ +322 template<>
│ │ │ │ │ +_3_2_3 struct _a_l_g_m_e_t_a___b_d_s_o_l_v_e<0,_n_o_r_e_l_a_x> {
│ │ │ │ │ +324 template
│ │ │ │ │ +_3_2_5 static void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d, const K& /*w*/)
│ │ │ │ │ +326 {
│ │ │ │ │ +327 A.solve(v,d);
│ │ │ │ │ +328 }
│ │ │ │ │ +329 };
│ │ │ │ │ +330
│ │ │ │ │ +331 // user calls
│ │ │ │ │ +332
│ │ │ │ │ +333 // default block recursion level = 1
│ │ │ │ │ +334
│ │ │ │ │ +336 template
│ │ │ │ │ +_3_3_7 void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d)
│ │ │ │ │ +338 {
│ │ │ │ │ +339 typename X::field_type w=1;
│ │ │ │ │ +340 _a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_1_,_n_o_r_e_l_a_x_>_:_:_b_d_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +341 }
│ │ │ │ │ +343 template
│ │ │ │ │ +_3_4_4 void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w)
│ │ │ │ │ +345 {
│ │ │ │ │ +346 _a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_1_,_w_i_t_h_r_e_l_a_x_>_:_:_b_d_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +347 }
│ │ │ │ │ +348
│ │ │ │ │ +349 // general block recursion level >= 0
│ │ │ │ │ +350
│ │ │ │ │ +352 template
│ │ │ │ │ +_3_5_3 void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d, _B_L_<_l_> /*bl*/)
│ │ │ │ │ +354 {
│ │ │ │ │ +355 typename X::field_type w=1;
│ │ │ │ │ +356 _a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_l_,_n_o_r_e_l_a_x_>_:_:_b_d_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +357 }
│ │ │ │ │ +359 template
│ │ │ │ │ +_3_6_0 void _b_d_s_o_l_v_e (const M& A, X& v, const Y& d, const K& w, _B_L_<_l_> /*bl*/)
│ │ │ │ │ +361 {
│ │ │ │ │ +362 _a_l_g_m_e_t_a___b_d_s_o_l_v_e_<_l_,_w_i_t_h_r_e_l_a_x_>_:_:_b_d_s_o_l_v_e(A,v,d,w);
│ │ │ │ │ +363 }
│ │ │ │ │ 364
│ │ │ │ │ -365 auto rows = index_constant();
│ │ │ │ │ -366 Hybrid::forEach(Hybrid::integralRange(rows), [&](auto&& i) {
│ │ │ │ │ -367 auto cols = index_constant::M()>();
│ │ │ │ │ -368 Hybrid::forEach(Hybrid::integralRange(cols), [&](auto&& j) {
│ │ │ │ │ -369 sum += (*this)[i][j].frobenius_norm2();
│ │ │ │ │ -370 });
│ │ │ │ │ -371 });
│ │ │ │ │ +365
│ │ │ │ │ +366 //============================================================
│ │ │ │ │ +367 // generic steps of iteration methods
│ │ │ │ │ +368 // Jacobi, Gauss-Seidel, SOR, SSOR
│ │ │ │ │ +369 // work directly on Ax=b, ie solve M(x^{i+1}-x^i) = w (b-Ax^i)
│ │ │ │ │ +370 // we can recurse over a fixed number of levels
│ │ │ │ │ +371 //============================================================
│ │ │ │ │ 372
│ │ │ │ │ -373 return sum;
│ │ │ │ │ -374 }
│ │ │ │ │ -375
│ │ │ │ │ -_3_7_7 _r_e_a_l___t_y_p_e _f_r_o_b_e_n_i_u_s___n_o_r_m () const
│ │ │ │ │ -378 {
│ │ │ │ │ -379 return sqrt(_f_r_o_b_e_n_i_u_s___n_o_r_m_2());
│ │ │ │ │ -380 }
│ │ │ │ │ -381
│ │ │ │ │ -_3_8_3 _r_e_a_l___t_y_p_e _i_n_f_i_n_i_t_y___n_o_r_m () const
│ │ │ │ │ -384 {
│ │ │ │ │ -385 using std::max;
│ │ │ │ │ -386 _r_e_a_l___t_y_p_e norm=0;
│ │ │ │ │ -387
│ │ │ │ │ -388 auto rows = index_constant();
│ │ │ │ │ -389 Hybrid::forEach(Hybrid::integralRange(rows), [&](auto&& i) {
│ │ │ │ │ -390 _r_e_a_l___t_y_p_e sum=0;
│ │ │ │ │ -391 auto cols = index_constant::M()>();
│ │ │ │ │ -392 Hybrid::forEach(Hybrid::integralRange(cols), [&](auto&& j) {
│ │ │ │ │ -393 sum += (*this)[i][j].infinity_norm();
│ │ │ │ │ -394 });
│ │ │ │ │ -395 norm = max(sum, norm);
│ │ │ │ │ -396 });
│ │ │ │ │ -397
│ │ │ │ │ -398 return norm;
│ │ │ │ │ -399 }
│ │ │ │ │ -400
│ │ │ │ │ -_4_0_2 _r_e_a_l___t_y_p_e _i_n_f_i_n_i_t_y___n_o_r_m___r_e_a_l () const
│ │ │ │ │ +373 // template meta program for iterative solver steps
│ │ │ │ │ +374 template
│ │ │ │ │ +_3_7_5 struct _a_l_g_m_e_t_a___i_t_s_t_e_p_s {
│ │ │ │ │ +376
│ │ │ │ │ +377 template
│ │ │ │ │ +_3_7_8 static void _d_b_g_s (const M& A, X& x, const Y& b, const K& w)
│ │ │ │ │ +379 {
│ │ │ │ │ +380 typedef typename M::ConstRowIterator rowiterator;
│ │ │ │ │ +381 typedef typename M::ConstColIterator coliterator;
│ │ │ │ │ +382 typedef typename Y::block_type bblock;
│ │ │ │ │ +383 bblock rhs;
│ │ │ │ │ +384
│ │ │ │ │ +385 X xold(x); // remember old x
│ │ │ │ │ +386
│ │ │ │ │ +387 rowiterator endi=A.end();
│ │ │ │ │ +388 for (rowiterator i=A.begin(); i!=endi; ++i)
│ │ │ │ │ +389 {
│ │ │ │ │ +390 rhs = b[i.index()]; // rhs = b_i
│ │ │ │ │ +391 coliterator endj=(*i).end();
│ │ │ │ │ +392 coliterator j=(*i).begin();
│ │ │ │ │ +393 if constexpr (IsNumber())
│ │ │ │ │ +394 {
│ │ │ │ │ +395 for (; j.index()();
│ │ │ │ │ -408 Hybrid::forEach(Hybrid::integralRange(rows), [&](auto&& i) {
│ │ │ │ │ -409 _r_e_a_l___t_y_p_e sum=0;
│ │ │ │ │ -410 auto cols = index_constant::M()>();
│ │ │ │ │ -411 Hybrid::forEach(Hybrid::integralRange(cols), [&](auto&& j) {
│ │ │ │ │ -412 sum += (*this)[i][j].infinity_norm_real();
│ │ │ │ │ -413 });
│ │ │ │ │ -414 norm = max(sum, norm);
│ │ │ │ │ -415 });
│ │ │ │ │ +404 for (; j.index() i
│ │ │ │ │ +408 (*j).mmv(x[j.index()],rhs); // rhs -= sum_{j>i} a_ij * xold_j
│ │ │ │ │ +409 _a_l_g_m_e_t_a___i_t_s_t_e_p_s_<_I_-_1_,_t_y_p_e_n_a_m_e_ _M_:_:_b_l_o_c_k___t_y_p_e_>_:_:_d_b_g_s(*diag,x[i.index
│ │ │ │ │ +()],rhs,w); // if I==1: xnew_i = rhs/a_ii
│ │ │ │ │ +410 }
│ │ │ │ │ +411 }
│ │ │ │ │ +412 // next two lines: xnew_i = w / a_ii * (b_i - sum_{j=i} a_ij * xold_j) + (1-w)*xold;
│ │ │ │ │ +413 x *= w;
│ │ │ │ │ +414 x.axpy(K(1)-w,xold);
│ │ │ │ │ +415 }
│ │ │ │ │ 416
│ │ │ │ │ -417 return norm;
│ │ │ │ │ -418 }
│ │ │ │ │ -419
│ │ │ │ │ -420 };
│ │ │ │ │ -421
│ │ │ │ │ -422
│ │ │ │ │ -426 template
│ │ │ │ │ -_4_2_7 struct FieldTraits< _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x >
│ │ │ │ │ -428 {
│ │ │ │ │ -_4_2_9 using _f_i_e_l_d___t_y_p_e = typename _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x::field_type;
│ │ │ │ │ -_4_3_0 using _r_e_a_l___t_y_p_e = typename _M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x::real_type;
│ │ │ │ │ -431 };
│ │ │ │ │ -432
│ │ │ │ │ -433
│ │ │ │ │ -439 template
│ │ │ │ │ -_4_4_0 std::ostream& _o_p_e_r_a_t_o_r_<_<_ (std::ostream& s, const
│ │ │ │ │ -_M_u_l_t_i_T_y_p_e_B_l_o_c_k_M_a_t_r_i_x_<_T_1_,_A_r_g_s_._._._>& m) {
│ │ │ │ │ -441 auto N = index_constant::N()>();
│ │ │ │ │ -442 auto M = index_constant::M()>();
│ │ │ │ │ -443 using namespace Dune::Hybrid;
│ │ │ │ │ -444 forEach(integralRange(N), [&](auto&& i) {
│ │ │ │ │ -445 using namespace Dune::Hybrid; // needed for icc, see issue #31
│ │ │ │ │ -446 forEach(integralRange(M), [&](auto&& j) {
│ │ │ │ │ -447 s << "\t(" << i << ", " << j << "): \n" << m[i][j];
│ │ │ │ │ -448 });
│ │ │ │ │ -449 });
│ │ │ │ │ -450 s << std::endl;
│ │ │ │ │ -451 return s;
│ │ │ │ │ -452 }
│ │ │ │ │ -453
│ │ │ │ │ -454 //make algmeta_itsteps known
│ │ │ │ │ -455 template
│ │ │ │ │ -456 struct algmeta_itsteps;
│ │ │ │ │ -457
│ │ │ │ │ -464 template
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,111 +1,65 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ _C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -io.hh File Reference
│ │ │ │ │ -_I_t_e_r_a_t_i_v_e_ _S_o_l_v_e_r_s_ _T_e_m_p_l_a_t_e_ _L_i_b_r_a_r_y_ _(_I_S_T_L_) » _S_p_a_r_s_e_ _M_a_t_r_i_x_ _a_n_d_ _V_e_c_t_o_r_ _c_l_a_s_s_e_s »
│ │ │ │ │ -_I_O_ _f_o_r_ _m_a_t_r_i_c_e_s_ _a_n_d_ _v_e_c_t_o_r_s_.
│ │ │ │ │ -Some generic functions for pretty printing vectors and matrices. _M_o_r_e_._._.
│ │ │ │ │ -#include