>;
│ │ │ │ │ -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
│ │ │ │ │ -_s_c_a_l_a_r_p_r_o_d_u_c_t_s_._h_h
│ │ │ │ │ -Define base class for scalar product and norm.
│ │ │ │ │ -_i_o_._h_h
│ │ │ │ │ -Some generic functions for pretty printing vectors and matrices.
│ │ │ │ │ -_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.
│ │ │ │ │ -_g_s_e_t_c_._h_h
│ │ │ │ │ -Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a
│ │ │ │ │ -generic way.
│ │ │ │ │ -_v_b_v_e_c_t_o_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...
│ │ │ │ │ -_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.
│ │ │ │ │ -_o_p_e_r_a_t_o_r_s_._h_h
│ │ │ │ │ -Define general, extensible interface for operators. The available
│ │ │ │ │ -implementation wraps a matrix.
│ │ │ │ │ +127 _I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e(RILU,v,d);
│ │ │ │ │ +128 }
│ │ │ │ │ +129
│ │ │ │ │ +137 template
│ │ │ │ │ +138 void _s_e_t_S_u_b_M_a_t_r_i_x(const M& A, S& rowset);
│ │ │ │ │ +139
│ │ │ │ │ +140 private:
│ │ │ │ │ +144 _r_i_l_u___t_y_p_e RILU;
│ │ │ │ │ +145 };
│ │ │ │ │ +146
│ │ │ │ │ +147
│ │ │ │ │ +148
│ │ │ │ │ +149 template
│ │ │ │ │ +150 template
│ │ │ │ │ +_1_5_1 std::size_t _I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_<_M_,_X_,_Y_>_:_:_c_o_p_y_T_o_L_o_c_a_l_M_a_t_r_i_x(const M& A, S&
│ │ │ │ │ +rowSet)
│ │ │ │ │ +152 {
│ │ │ │ │ +153 // Calculate consecutive indices for local problem
│ │ │ │ │ +154 // while preserving the ordering
│ │ │ │ │ +155 typedef typename M::size_type size_type;
│ │ │ │ │ +156 typedef std::map IndexMap;
│ │ │ │ │ +157 typedef typename IndexMap::iterator IMIter;
│ │ │ │ │ +158 IndexMap indexMap;
│ │ │ │ │ +159 IMIter guess = indexMap.begin();
│ │ │ │ │ +160 size_type localIndex=0;
│ │ │ │ │ +161
│ │ │ │ │ +162 typedef typename S::const_iterator SIter;
│ │ │ │ │ +163 for(SIter rowIdx = rowSet.begin(), rowEnd=rowSet.end();
│ │ │ │ │ +164 rowIdx!= rowEnd; ++rowIdx, ++localIndex)
│ │ │ │ │ +165 guess = indexMap.insert(guess,
│ │ │ │ │ +166 std::make_pair(*rowIdx,localIndex));
│ │ │ │ │ +167
│ │ │ │ │ +168
│ │ │ │ │ +169 // Build Matrix for local subproblem
│ │ │ │ │ +170 ILU.setSize(rowSet.size(),rowSet.size());
│ │ │ │ │ +171 ILU.setBuildMode(matrix_type::row_wise);
│ │ │ │ │ +172
│ │ │ │ │ +173 // Create sparsity pattern
│ │ │ │ │ +174 typedef typename matrix_type::CreateIterator CIter;
│ │ │ │ │ +175 CIter rowCreator = ILU.createbegin();
│ │ │ │ │ +176 std::size_t offset=0;
│ │ │ │ │ +177 for(SIter rowIdx = rowSet.begin(), rowEnd=rowSet.end();
│ │ │ │ │ +178 rowIdx!= rowEnd; ++rowIdx, ++rowCreator) {
│ │ │ │ │ +179 // See which row entries are in our subset and add them to
│ │ │ │ │ +180 // the sparsity pattern
│ │ │ │ │ +181 guess = indexMap.begin();
│ │ │ │ │ +182
│ │ │ │ │ +183 for(typename matrix_type::ConstColIterator _c_o_l=A[*rowIdx].begin(),
│ │ │ │ │ +184 endcol=A[*rowIdx]._e_n_d(); _c_o_l != endcol; ++_c_o_l) {
│ │ │ │ │ +185 // search for the entry in the row set
│ │ │ │ │ +186 guess = indexMap.find(_c_o_l.index());
│ │ │ │ │ +187 if(guess!=indexMap.end()) {
│ │ │ │ │ +188 // add local index to row
│ │ │ │ │ +189 rowCreator.insert(guess->second);
│ │ │ │ │ +190 offset=std::max(offset,(std::size_t)std::abs((int)(guess->second-
│ │ │ │ │ +rowCreator.index())));
│ │ │ │ │ +191 }
│ │ │ │ │ +192 }
│ │ │ │ │ +193
│ │ │ │ │ +194 }
│ │ │ │ │ +195
│ │ │ │ │ +196 // Insert the matrix values for the local problem
│ │ │ │ │ +197 typename matrix_type::iterator iluRow=ILU.begin();
│ │ │ │ │ +198
│ │ │ │ │ +199 for(SIter rowIdx = rowSet.begin(), rowEnd=rowSet.end();
│ │ │ │ │ +200 rowIdx!= rowEnd; ++rowIdx, ++iluRow) {
│ │ │ │ │ +201 // See which row entries are in our subset and add them to
│ │ │ │ │ +202 // the sparsity pattern
│ │ │ │ │ +203 typename matrix_type::ColIterator localCol=iluRow->begin();
│ │ │ │ │ +204 for(typename matrix_type::ConstColIterator _c_o_l=A[*rowIdx].begin(),
│ │ │ │ │ +205 endcol=A[*rowIdx]._e_n_d(); _c_o_l != endcol; ++_c_o_l) {
│ │ │ │ │ +206 // search for the entry in the row set
│ │ │ │ │ +207 guess = indexMap.find(_c_o_l.index());
│ │ │ │ │ +208 if(guess!=indexMap.end()) {
│ │ │ │ │ +209 // set local value
│ │ │ │ │ +210 (*localCol)=(*col);
│ │ │ │ │ +211 ++localCol;
│ │ │ │ │ +212 }
│ │ │ │ │ +213 }
│ │ │ │ │ +214 }
│ │ │ │ │ +215 return offset;
│ │ │ │ │ +216 }
│ │ │ │ │ +217
│ │ │ │ │ +218
│ │ │ │ │ +219 template
│ │ │ │ │ +220 template
│ │ │ │ │ +_2_2_1 void _I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_<_M_,_X_,_Y_>_:_:_s_e_t_S_u_b_M_a_t_r_i_x(const M& A, S& rowSet)
│ │ │ │ │ +222 {
│ │ │ │ │ +223 this->copyToLocalMatrix(A,rowSet);
│ │ │ │ │ +224 _I_L_U_:_:_b_l_o_c_k_I_L_U_0_D_e_c_o_m_p_o_s_i_t_i_o_n(this->ILU);
│ │ │ │ │ +225 }
│ │ │ │ │ +226
│ │ │ │ │ +227 template
│ │ │ │ │ +228 template
│ │ │ │ │ +_2_2_9 void _I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_<_M_,_X_,_Y_>_:_:_s_e_t_S_u_b_M_a_t_r_i_x(const M& A, S& rowSet)
│ │ │ │ │ +230 {
│ │ │ │ │ +231 std::size_t offset=copyToLocalMatrix(A,rowSet);
│ │ │ │ │ +232 RILU.setSize(rowSet.size(),rowSet.size(), (1+2*offset)*rowSet.size());
│ │ │ │ │ +233 RILU.setBuildMode(matrix_type::row_wise);
│ │ │ │ │ +234 _I_L_U_:_:_b_l_o_c_k_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n(this->ILU, (offset+1)/2, RILU);
│ │ │ │ │ +235 }
│ │ │ │ │ +236
│ │ │ │ │ +238} // end name space DUNE
│ │ │ │ │ +239
│ │ │ │ │ +240
│ │ │ │ │ +241#endif
│ │ │ │ │ _p_r_e_c_o_n_d_i_t_i_o_n_e_r_s_._h_h
│ │ │ │ │ Define general preconditioner interface.
│ │ │ │ │ -_i_l_u_._h_h
│ │ │ │ │ -The incomplete LU factorization kernels.
│ │ │ │ │ -_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
│ │ │ │ │ +_m_a_t_r_i_x_._h_h
│ │ │ │ │ +A dynamic dense block matrix class.
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_c_o_p_y_T_o_L_o_c_a_l_M_a_t_r_i_x
│ │ │ │ │ +std::size_t copyToLocalMatrix(const M &A, S &rowset)
│ │ │ │ │ +Copy the local part of the global matrix to ILU.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:151
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_s_e_t_S_u_b_M_a_t_r_i_x
│ │ │ │ │ +void setSubMatrix(const M &A, S &rowset)
│ │ │ │ │ +Set the data of the local problem.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:229
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_s_e_t_S_u_b_M_a_t_r_i_x
│ │ │ │ │ +void setSubMatrix(const M &A, S &rowset)
│ │ │ │ │ +Set the data of the local problem.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:221
│ │ │ │ │ +_c_o_l
│ │ │ │ │ +Col col
│ │ │ │ │ +DDeeffiinniittiioonn matrixmatrix.hh:351
│ │ │ │ │ _D_u_n_e
│ │ │ │ │ DDeeffiinniittiioonn allocator.hh:11
│ │ │ │ │ -_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
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e
│ │ │ │ │ +void blockILUBacksolve(const M &A, X &v, const Y &d)
│ │ │ │ │ +LU backsolve with stored inverse.
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:94
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_b_l_o_c_k_I_L_U_0_D_e_c_o_m_p_o_s_i_t_i_o_n
│ │ │ │ │ +void blockILU0Decomposition(M &A)
│ │ │ │ │ +compute ILU decomposition of A. A is overwritten by its decomposition
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:33
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_:_:_b_l_o_c_k_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n
│ │ │ │ │ +void blockILUDecomposition(const M &A, int n, M &ILU)
│ │ │ │ │ +DDeeffiinniittiioonn ilu.hh:167
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r
│ │ │ │ │ +base class encapsulating common algorithms of ILU0SubdomainSolver and
│ │ │ │ │ +ILUNSubdomainSolver.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:36
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_I_L_U
│ │ │ │ │ +matrix_type ILU
│ │ │ │ │ +The ILU0 decomposition of the matrix, or the local matrix.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:67
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_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
│ │ │ │ │ +The domain type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:41
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_~_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r
│ │ │ │ │ +virtual ~ILUSubdomainSolver()
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:53
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_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
│ │ │ │ │ +The range type of the preconditioner.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:43
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +std::remove_const< M >::type matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:39
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +virtual void apply(X &v, const Y &d)=0
│ │ │ │ │ +Apply the subdomain solver.
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r
│ │ │ │ │ +Exact subdomain solver using ILU(p) with appropriate p.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:78
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_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
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:84
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_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
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:86
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_r_i_l_u___t_y_p_e
│ │ │ │ │ +std::remove_const< M >::type rilu_type
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:82
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +std::remove_const< M >::type 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
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:81
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_0_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_a_p_p_l_y
│ │ │ │ │ +void apply(X &v, const Y &d)
│ │ │ │ │ +Apply the subdomain solver.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:93
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:111
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_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
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:117
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_m_a_t_r_i_x___t_y_p_e
│ │ │ │ │ +std::remove_const< M >::type matrix_type
│ │ │ │ │ +The matrix type the preconditioner is for.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:114
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_e_r_:_:_r_i_l_u___t_y_p_e
│ │ │ │ │ +std::remove_const< M >::type rilu_type
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:115
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_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
│ │ │ │ │ +Apply the subdomain solver.
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:125
│ │ │ │ │ +_D_u_n_e_:_:_I_L_U_N_S_u_b_d_o_m_a_i_n_S_o_l_v_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
│ │ │ │ │ +DDeeffiinniittiioonn ilusubdomainsolver.hh:119
│ │ │ │ │ +_D_u_n_e_:_:_M_a_t_r_i_x_:_:_e_n_d
│ │ │ │ │ +RowIterator end()
│ │ │ │ │ +Get iterator to one beyond last row.
│ │ │ │ │ +DDeeffiinniittiioonn matrix.hh:616
│ │ │ │ │ ===============================================================================
│ │ │ │ │ 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: matrixmarket.hh File Reference
│ │ │ │ +dune-istl: preconditioners.hh File Reference
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -72,264 +72,104 @@
│ │ │ │ duneistl
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices.
│ │ │ │ +
Define general preconditioner interface.
│ │ │ │ More...
│ │ │ │ -
#include <algorithm>
│ │ │ │ +
#include <cmath>
│ │ │ │
#include <complex>
│ │ │ │ -
#include <cstddef>
│ │ │ │ -
#include <fstream>
│ │ │ │ -
#include <ios>
│ │ │ │
#include <iostream>
│ │ │ │ -
#include <istream>
│ │ │ │ -
#include <limits>
│ │ │ │ -
#include <ostream>
│ │ │ │ -
#include <set>
│ │ │ │ -
#include <sstream>
│ │ │ │ +
#include <iomanip>
│ │ │ │ +
#include <memory>
│ │ │ │
#include <string>
│ │ │ │ -
#include <tuple>
│ │ │ │ -
#include <type_traits>
│ │ │ │ -
#include <vector>
│ │ │ │ -
#include <dune/common/exceptions.hh>
│ │ │ │ -
#include <dune/common/fmatrix.hh>
│ │ │ │ -
#include <dune/common/fvector.hh>
│ │ │ │ -
#include <dune/common/hybridutilities.hh>
│ │ │ │ -
#include <dune/common/stdstreams.hh>
│ │ │ │
#include <dune/common/simd/simd.hh>
│ │ │ │ -
#include <dune/istl/bcrsmatrix.hh>
│ │ │ │ -
#include <dune/istl/bvector.hh>
│ │ │ │ -
#include <dune/istl/matrixutils.hh>
│ │ │ │ -
#include <dune/istl/owneroverlapcopy.hh>
│ │ │ │ +
#include <dune/common/parametertree.hh>
│ │ │ │ +
#include <dune/istl/solverregistry.hh>
│ │ │ │ +
#include "preconditioner.hh"
│ │ │ │ +
#include "solver.hh"
│ │ │ │ +
#include "solvercategory.hh"
│ │ │ │ +
#include "istlexception.hh"
│ │ │ │ +
#include "matrixutils.hh"
│ │ │ │ +
#include "gsetc.hh"
│ │ │ │ +
#include "dilu.hh"
│ │ │ │ +
#include "ildl.hh"
│ │ │ │ +
#include "ilu.hh"
│ │ │ │
│ │ │ │
Go to the source code of this file.
│ │ │ │
│ │ │ │ |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_numeric_type< T > |
│ │ │ │ -| | Helper metaprogram to get the matrix market string representation of the numeric type. More...
|
│ │ │ │ +| class | Dune::InverseOperator2Preconditioner< O, c > |
│ │ │ │ +| | Turns an InverseOperator into a Preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_numeric_type< int > |
│ │ │ │ +| class | Dune::SeqSSOR< M, X, Y, l > |
│ │ │ │ +| | Sequential SSOR preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_numeric_type< double > |
│ │ │ │ +| class | Dune::SeqSOR< M, X, Y, l > |
│ │ │ │ +| | Sequential SOR preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_numeric_type< float > |
│ │ │ │ +| class | Dune::SeqJac< M, X, Y, l > |
│ │ │ │ +| | The sequential jacobian preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_numeric_type< std::complex< double > > |
│ │ │ │ +| class | Dune::SeqDILU< M, X, Y, l > |
│ │ │ │ +| | Sequential DILU preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_numeric_type< std::complex< float > > |
│ │ │ │ +| class | Dune::SeqILU< M, X, Y, l > |
│ │ │ │ +| | Sequential ILU preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_header_printer< BCRSMatrix< T, A > > |
│ │ │ │ +| class | Dune::Richardson< X, Y > |
│ │ │ │ +| | Richardson preconditioner. More...
|
│ │ │ │ | |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_header_printer< BlockVector< B, A > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_header_printer< FieldVector< T, j > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_header_printer< FieldMatrix< T, i, j > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_block_structure_header< BlockVector< T, A > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_block_structure_header< BlockVector< FieldVector< T, i >, A > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_block_structure_header< BCRSMatrix< T, A > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_block_structure_header< BCRSMatrix< FieldMatrix< T, i, j >, A > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_block_structure_header< FieldMatrix< T, i, j > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_block_structure_header< FieldVector< T, i > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::MMHeader |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::IndexData< T > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::NumericWrapper< T > |
│ │ │ │ -| | a wrapper class of numeric values. More...
|
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::PatternDummy |
│ │ │ │ -| | Utility class for marking the pattern type of the MatrixMarket matrices. More...
|
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::NumericWrapper< PatternDummy > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::MatrixValuesSetter< D, brows, bcols > |
│ │ │ │ -| | Functor to the data values of the matrix. More...
|
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::MatrixValuesSetter< PatternDummy, brows, bcols > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::is_complex< T > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::is_complex< std::complex< T > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_multipliers< M > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_multipliers< BCRSMatrix< B, A > > |
│ │ │ │ -| |
│ │ │ │ -| struct | Dune::MatrixMarketImpl::mm_multipliers< BCRSMatrix< FieldMatrix< B, i, j >, A > > |
│ │ │ │ -| |
│ │ │ │ -| class | Dune::MatrixMarketFormatError |
│ │ │ │ +| class | Dune::SeqILDL< M, X, Y > |
│ │ │ │ +| | sequential ILDL preconditioner More...
|
│ │ │ │ | |
│ │ │ │
│ │ │ │ - |
│ │ │ │ -| enum | Dune::MatrixMarketImpl::LineType { Dune::MatrixMarketImpl::MM_HEADER
│ │ │ │ -, Dune::MatrixMarketImpl::MM_ISTLSTRUCT
│ │ │ │ -, Dune::MatrixMarketImpl::DATA
│ │ │ │ - } |
│ │ │ │ -| |
│ │ │ │ -| enum | { Dune::MatrixMarketImpl::MM_MAX_LINE_LENGTH =1025
│ │ │ │ - } |
│ │ │ │ -| |
│ │ │ │ -| enum | Dune::MatrixMarketImpl::MM_TYPE { Dune::MatrixMarketImpl::coordinate_type
│ │ │ │ -, Dune::MatrixMarketImpl::array_type
│ │ │ │ -, Dune::MatrixMarketImpl::unknown_type
│ │ │ │ - } |
│ │ │ │ -| |
│ │ │ │ -| enum | Dune::MatrixMarketImpl::MM_CTYPE {
│ │ │ │ - Dune::MatrixMarketImpl::integer_type
│ │ │ │ -, Dune::MatrixMarketImpl::double_type
│ │ │ │ -, Dune::MatrixMarketImpl::complex_type
│ │ │ │ -, Dune::MatrixMarketImpl::pattern
│ │ │ │ -,
│ │ │ │ - Dune::MatrixMarketImpl::unknown_ctype
│ │ │ │ -
│ │ │ │ - } |
│ │ │ │ -| |
│ │ │ │ -| enum | Dune::MatrixMarketImpl::MM_STRUCTURE {
│ │ │ │ - Dune::MatrixMarketImpl::general
│ │ │ │ -, Dune::MatrixMarketImpl::symmetric
│ │ │ │ -, Dune::MatrixMarketImpl::skew_symmetric
│ │ │ │ -, Dune::MatrixMarketImpl::hermitian
│ │ │ │ -,
│ │ │ │ - Dune::MatrixMarketImpl::unknown_structure
│ │ │ │ -
│ │ │ │ - } |
│ │ │ │ -| |
│ │ │ │ + |
│ │ │ │ +| template<class M , class X , class Y , int l = 1> |
│ │ │ │ +| using | Dune::SeqGS = SeqSOR< M, X, Y, l > |
│ │ │ │ +| | Sequential Gauss Seidel preconditioner.
|
│ │ │ │ +| |
│ │ │ │
│ │ │ │ |
│ │ │ │ -| bool | Dune::MatrixMarketImpl::lineFeed (std::istream &file) |
│ │ │ │ -| |
│ │ │ │ -| void | Dune::MatrixMarketImpl::skipComments (std::istream &file) |
│ │ │ │ -| |
│ │ │ │ -| bool | Dune::MatrixMarketImpl::readMatrixMarketBanner (std::istream &file, MMHeader &mmHeader) |
│ │ │ │ -| |
│ │ │ │ -| template<std::size_t brows, std::size_t bcols> |
│ │ │ │ -| std::tuple< std::size_t, std::size_t, std::size_t > | Dune::MatrixMarketImpl::calculateNNZ (std::size_t rows, std::size_t cols, std::size_t entries, const MMHeader &header) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T > |
│ │ │ │ -| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, NumericWrapper< T > &num) |
│ │ │ │ -| |
│ │ │ │ -| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, NumericWrapper< PatternDummy > &num) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T > |
│ │ │ │ -| bool | Dune::MatrixMarketImpl::operator< (const IndexData< T > &i1, const IndexData< T > &i2) |
│ │ │ │ -| | LessThan operator.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename T > |
│ │ │ │ -| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, IndexData< T > &data) |
│ │ │ │ -| | Read IndexData from a stream.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename T > |
│ │ │ │ -| std::istream & | Dune::MatrixMarketImpl::operator>> (std::istream &is, IndexData< NumericWrapper< std::complex< T > > > &data) |
│ │ │ │ -| | Read IndexData from a stream. Specialization for std::complex.
|
│ │ │ │ -| |
│ │ │ │ -| template<class T > |
│ │ │ │ -| std::enable_if_t<!is_complex< T >::value, T > | Dune::MatrixMarketImpl::conj (const T &r) |
│ │ │ │ -| |
│ │ │ │ -| template<class T > |
│ │ │ │ -| std::enable_if_t< is_complex< T >::value, T > | Dune::MatrixMarketImpl::conj (const T &r) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A , typename D > |
│ │ │ │ -| void | Dune::MatrixMarketImpl::readSparseEntries (Dune::BCRSMatrix< T, A > &matrix, std::istream &file, std::size_t entries, const MMHeader &mmHeader, const D &) |
│ │ │ │ -| |
│ │ │ │ -| std::tuple< std::string, std::string > | Dune::MatrixMarketImpl::splitFilename (const std::string &filename) |
│ │ │ │ -| |
│ │ │ │ -| void | Dune::mm_read_header (std::size_t &rows, std::size_t &cols, MatrixMarketImpl::MMHeader &header, std::istream &istr, bool isVector) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A > |
│ │ │ │ -| void | Dune::mm_read_vector_entries (Dune::BlockVector< T, A > &vector, std::size_t size, std::istream &istr, size_t lane) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A , int entries> |
│ │ │ │ -| void | Dune::mm_read_vector_entries (Dune::BlockVector< Dune::FieldVector< T, entries >, A > &vector, std::size_t size, std::istream &istr, size_t lane) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A > |
│ │ │ │ -| void | Dune::readMatrixMarket (Dune::BlockVector< T, A > &vector, std::istream &istr) |
│ │ │ │ -| | Reads a BlockVector from a matrix market file.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A > |
│ │ │ │ -| void | Dune::readMatrixMarket (Dune::BCRSMatrix< T, A > &matrix, std::istream &istr) |
│ │ │ │ -| | Reads a sparse matrix from a matrix market file.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename B > |
│ │ │ │ -| void | Dune::mm_print_entry (const B &entry, std::size_t rowidx, std::size_t colidx, std::ostream &ostr) |
│ │ │ │ -| |
│ │ │ │ -| template<typename V > |
│ │ │ │ -| void | Dune::mm_print_vector_entry (const V &entry, std::ostream &ostr, const std::integral_constant< int, 1 > &, size_t lane) |
│ │ │ │ -| |
│ │ │ │ -| template<typename V > |
│ │ │ │ -| void | Dune::mm_print_vector_entry (const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &, size_t lane) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A > |
│ │ │ │ -| std::size_t | Dune::countEntries (const BlockVector< T, A > &vector) |
│ │ │ │ -| |
│ │ │ │ -| template<typename T , typename A , int i> |
│ │ │ │ -| std::size_t | Dune::countEntries (const BlockVector< FieldVector< T, i >, A > &vector) |
│ │ │ │ -| |
│ │ │ │ -| template<typename V > |
│ │ │ │ -| void | Dune::writeMatrixMarket (const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &) |
│ │ │ │ -| |
│ │ │ │ -| template<typename M > |
│ │ │ │ -| void | Dune::writeMatrixMarket (const M &matrix, std::ostream &ostr, const std::integral_constant< int, 1 > &) |
│ │ │ │ -| |
│ │ │ │ -| template<typename M > |
│ │ │ │ -| void | Dune::writeMatrixMarket (const M &matrix, std::ostream &ostr) |
│ │ │ │ -| | writes a ISTL matrix or vector to a stream in matrix market format.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename M > |
│ │ │ │ -| void | Dune::storeMatrixMarket (const M &matrix, std::string filename, int prec=default_precision) |
│ │ │ │ -| | Stores a parallel matrix/vector in matrix market format in a file.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename M , typename G , typename L > |
│ │ │ │ -| void | Dune::storeMatrixMarket (const M &matrix, std::string filename, const OwnerOverlapCopyCommunication< G, L > &comm, bool storeIndices=true, int prec=default_precision) |
│ │ │ │ -| | Stores a parallel matrix/vector in matrix market format in a file.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename M , typename G , typename L > |
│ │ │ │ -| void | Dune::loadMatrixMarket (M &matrix, const std::string &filename, OwnerOverlapCopyCommunication< G, L > &comm, bool readIndices=true) |
│ │ │ │ -| | Load a parallel matrix/vector stored in matrix market format.
|
│ │ │ │ -| |
│ │ │ │ -| template<typename M > |
│ │ │ │ -| void | Dune::loadMatrixMarket (M &matrix, const std::string &filename) |
│ │ │ │ -| | Load a matrix/vector stored in matrix market format.
|
│ │ │ │ -| |
│ │ │ │ -
│ │ │ │ - |
│ │ │ │ -| static const int | Dune::default_precision = -1 |
│ │ │ │ -| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("ssor", defaultPreconditionerBlockLevelCreator< Dune::SeqSSOR >()) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("sor", defaultPreconditionerBlockLevelCreator< Dune::SeqSOR >()) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("gs", defaultPreconditionerBlockLevelCreator< Dune::SeqGS >()) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("jac", defaultPreconditionerBlockLevelCreator< Dune::SeqJac >()) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("dilu", defaultPreconditionerBlockLevelCreator< Dune::SeqDILU >()) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("ilu", defaultPreconditionerBlockLevelCreator< Dune::SeqILU >()) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("richardson", [](auto tl, const auto &, const ParameterTree &config){ using D=typename Dune::TypeListElement< 1, decltype(tl)>::type;using R=typename Dune::TypeListElement< 2, decltype(tl)>::type;return std::make_shared< Richardson< D, R > >(config);}) |
│ │ │ │ +| |
│ │ │ │ +| | Dune::DUNE_REGISTER_PRECONDITIONER ("ildl", defaultPreconditionerCreator< Dune::SeqILDL >()) |
│ │ │ │ +| |
│ │ │ │
│ │ │ │
│ │ │ │ -
Provides classes for reading and writing MatrixMarket Files with an extension for parallel matrices.
│ │ │ │ -
- Author
- Markus Blatt
│ │ │ │ +
Define general preconditioner interface.
│ │ │ │ +
Wrap the methods implemented by ISTL in this interface. However, the interface is extensible such that new preconditioners can be implemented and used with the solvers.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,316 +1,96 @@
│ │ │ │ │ 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 | _E_n_u_m_e_r_a_t_i_o_n_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ -matrixmarket.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_.
│ │ │ │ │ -Provides classes for reading and writing MatrixMarket Files with an extension
│ │ │ │ │ -for parallel matrices. _M_o_r_e_._._.
│ │ │ │ │ -#include
│ │ │ │ │ +_C_l_a_s_s_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +preconditioners.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_) » _I_t_e_r_a_t_i_v_e_ _S_o_l_v_e_r_s » _P_r_e_c_o_n_d_i_t_i_o_n_e_r_s
│ │ │ │ │ +Define general preconditioner interface. _M_o_r_e_._._.
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ +#include
│ │ │ │ │ +#include
│ │ │ │ │ #include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ -#include
│ │ │ │ │ #include
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_b_v_e_c_t_o_r_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_m_a_t_r_i_x_u_t_i_l_s_._h_h>
│ │ │ │ │ -#include <_d_u_n_e_/_i_s_t_l_/_o_w_n_e_r_o_v_e_r_l_a_p_c_o_p_y_._h_h>
│ │ │ │ │ +#include
│ │ │ │ │ +#include <_d_u_n_e_/_i_s_t_l_/_s_o_l_v_e_r_r_e_g_i_s_t_r_y_._h_h>
│ │ │ │ │ +#include "_p_r_e_c_o_n_d_i_t_i_o_n_e_r_._h_h"
│ │ │ │ │ +#include "_s_o_l_v_e_r_._h_h"
│ │ │ │ │ +#include "_s_o_l_v_e_r_c_a_t_e_g_o_r_y_._h_h"
│ │ │ │ │ +#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ +#include "_m_a_t_r_i_x_u_t_i_l_s_._h_h"
│ │ │ │ │ +#include "_g_s_e_t_c_._h_h"
│ │ │ │ │ +#include "_d_i_l_u_._h_h"
│ │ │ │ │ +#include "_i_l_d_l_._h_h"
│ │ │ │ │ +#include "_i_l_u_._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
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___n_u_m_e_r_i_c___t_y_p_e_<_ _T_ _>
│ │ │ │ │ - Helper metaprogram to get the matrix market string representation of
│ │ │ │ │ - the numeric type. _M_o_r_e_._._.
│ │ │ │ │ +class _D_u_n_e_:_:_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_ _O_,_ _c_ _>
│ │ │ │ │ + Turns an _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r into a _P_r_e_c_o_n_d_i_t_i_o_n_e_r. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___n_u_m_e_r_i_c___t_y_p_e_<_ _i_n_t_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_S_S_O_R_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential SSOR preconditioner. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___n_u_m_e_r_i_c___t_y_p_e_<_ _d_o_u_b_l_e_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_S_O_R_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential SOR preconditioner. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___n_u_m_e_r_i_c___t_y_p_e_<_ _f_l_o_a_t_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_J_a_c_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + The sequential jacobian preconditioner. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___n_u_m_e_r_i_c___t_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _d_o_u_b_l_e_ _>_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_D_I_L_U_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential _D_I_L_U preconditioner. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___n_u_m_e_r_i_c___t_y_p_e_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _f_l_o_a_t_ _>_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_I_L_U_<_ _M_,_ _X_,_ _Y_,_ _l_ _>
│ │ │ │ │ + Sequential _I_L_U preconditioner. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___h_e_a_d_e_r___p_r_i_n_t_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _T_,_ _A_ _>_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_R_i_c_h_a_r_d_s_o_n_<_ _X_,_ _Y_ _>
│ │ │ │ │ + _R_i_c_h_a_r_d_s_o_n preconditioner. _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___h_e_a_d_e_r___p_r_i_n_t_e_r_<_ _B_l_o_c_k_V_e_c_t_o_r_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │ +class _D_u_n_e_:_:_S_e_q_I_L_D_L_<_ _M_,_ _X_,_ _Y_ _>
│ │ │ │ │ + sequential ILDL preconditioner _M_o_r_e_._._.
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___h_e_a_d_e_r___p_r_i_n_t_e_r_<_ _F_i_e_l_d_V_e_c_t_o_r_<_ _T_,_ _j_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___h_e_a_d_e_r___p_r_i_n_t_e_r_<_ _F_i_e_l_d_M_a_t_r_i_x_<_ _T_,_ _i_,_ _j_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r_<_ _B_l_o_c_k_V_e_c_t_o_r_<_ _T_,_ _A_ _>
│ │ │ │ │ - _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r_<_ _B_l_o_c_k_V_e_c_t_o_r_<
│ │ │ │ │ - _F_i_e_l_d_V_e_c_t_o_r_<_ _T_,_ _i_ _>_,_ _A_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<_ _T_,_ _A_ _>
│ │ │ │ │ - _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r_<_ _B_C_R_S_M_a_t_r_i_x_<
│ │ │ │ │ - _F_i_e_l_d_M_a_t_r_i_x_<_ _T_,_ _i_,_ _j_ _>_,_ _A_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r_<_ _F_i_e_l_d_M_a_t_r_i_x_<_ _T_,_ _i_,
│ │ │ │ │ - _j_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r_<_ _F_i_e_l_d_V_e_c_t_o_r_<_ _T_,_ _i_ _>
│ │ │ │ │ - _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M_H_e_a_d_e_r
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_I_n_d_e_x_D_a_t_a_<_ _T_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_N_u_m_e_r_i_c_W_r_a_p_p_e_r_<_ _T_ _>
│ │ │ │ │ - a wrapper class of numeric values. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_P_a_t_t_e_r_n_D_u_m_m_y
│ │ │ │ │ - Utility class for marking the pattern type of the MatrixMarket
│ │ │ │ │ - matrices. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_N_u_m_e_r_i_c_W_r_a_p_p_e_r_<_ _P_a_t_t_e_r_n_D_u_m_m_y_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_a_t_r_i_x_V_a_l_u_e_s_S_e_t_t_e_r_<_ _D_,_ _b_r_o_w_s_,_ _b_c_o_l_s_ _>
│ │ │ │ │ - Functor to the data values of the matrix. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_a_t_r_i_x_V_a_l_u_e_s_S_e_t_t_e_r_<_ _P_a_t_t_e_r_n_D_u_m_m_y_,_ _b_r_o_w_s_,_ _b_c_o_l_s
│ │ │ │ │ - _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_i_s___c_o_m_p_l_e_x_<_ _T_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_i_s___c_o_m_p_l_e_x_<_ _s_t_d_:_:_c_o_m_p_l_e_x_<_ _T_ _>_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___m_u_l_t_i_p_l_i_e_r_s_<_ _M_ _>
│ │ │ │ │ -
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___m_u_l_t_i_p_l_i_e_r_s_<_ _B_C_R_S_M_a_t_r_i_x_<_ _B_,_ _A_ _>_ _>
│ │ │ │ │ +NNaammeessppaacceess
│ │ │ │ │ +namespace _D_u_n_e
│ │ │ │ │
│ │ │ │ │ -struct _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_m_m___m_u_l_t_i_p_l_i_e_r_s_<_ _B_C_R_S_M_a_t_r_i_x_<_ _F_i_e_l_d_M_a_t_r_i_x_<_ _B_,_ _i_,
│ │ │ │ │ - _j_ _>_,_ _A_ _>_ _>
│ │ │ │ │ +TTyyppeeddeeffss
│ │ │ │ │ +template
│ │ │ │ │ +using _D_u_n_e_:_:_S_e_q_G_S = _S_e_q_S_O_R< M, X, Y, l >
│ │ │ │ │ + Sequential Gauss Seidel preconditioner.
│ │ │ │ │
│ │ │ │ │ - class _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_F_o_r_m_a_t_E_r_r_o_r
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("ssor",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_S_S_O_R >())
│ │ │ │ │
│ │ │ │ │ -NNaammeessppaacceess
│ │ │ │ │ -namespace _D_u_n_e
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("sor",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_S_O_R >())
│ │ │ │ │
│ │ │ │ │ -namespace _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("gs",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_G_S >())
│ │ │ │ │
│ │ │ │ │ -EEnnuummeerraattiioonnss
│ │ │ │ │ -enum _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_L_i_n_e_T_y_p_e { _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M___H_E_A_D_E_R ,
│ │ │ │ │ - _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M___I_S_T_L_S_T_R_U_C_T , _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_D_A_T_A }
│ │ │ │ │ -
│ │ │ │ │ -enum { _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M___M_A_X___L_I_N_E___L_E_N_G_T_H =1025 }
│ │ │ │ │ -
│ │ │ │ │ -enum _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M___T_Y_P_E { _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:
│ │ │ │ │ - _c_o_o_r_d_i_n_a_t_e___t_y_p_e , _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_a_r_r_a_y___t_y_p_e , _D_u_n_e_:_:
│ │ │ │ │ - _M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_u_n_k_n_o_w_n___t_y_p_e }
│ │ │ │ │ -
│ │ │ │ │ -enum _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M___C_T_Y_P_E {
│ │ │ │ │ - _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_i_n_t_e_g_e_r___t_y_p_e , _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:
│ │ │ │ │ - _d_o_u_b_l_e___t_y_p_e , _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_c_o_m_p_l_e_x___t_y_p_e , _D_u_n_e_:_:
│ │ │ │ │ - _M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_p_a_t_t_e_r_n ,
│ │ │ │ │ - _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_u_n_k_n_o_w_n___c_t_y_p_e
│ │ │ │ │ - }
│ │ │ │ │ -
│ │ │ │ │ -enum _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M___S_T_R_U_C_T_U_R_E {
│ │ │ │ │ - _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_g_e_n_e_r_a_l , _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_s_y_m_m_e_t_r_i_c ,
│ │ │ │ │ - _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_s_k_e_w___s_y_m_m_e_t_r_i_c , _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:
│ │ │ │ │ - _h_e_r_m_i_t_i_a_n ,
│ │ │ │ │ - _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_u_n_k_n_o_w_n___s_t_r_u_c_t_u_r_e
│ │ │ │ │ - }
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("jac",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_J_a_c >())
│ │ │ │ │
│ │ │ │ │ -FFuunnccttiioonnss
│ │ │ │ │ - bool _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_l_i_n_e_F_e_e_d (std::
│ │ │ │ │ - istream &file)
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("dilu",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_D_I_L_U >())
│ │ │ │ │
│ │ │ │ │ - void _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_s_k_i_p_C_o_m_m_e_n_t_s
│ │ │ │ │ - (std::istream &file)
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("ilu",
│ │ │ │ │ + _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_B_l_o_c_k_L_e_v_e_l_C_r_e_a_t_o_r< _D_u_n_e_:_:_S_e_q_I_L_U >())
│ │ │ │ │
│ │ │ │ │ - bool _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:
│ │ │ │ │ - _r_e_a_d_M_a_t_r_i_x_M_a_r_k_e_t_B_a_n_n_e_r (std::istream
│ │ │ │ │ - &file, _M_M_H_e_a_d_e_r &mmHeader)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::tuple< std::size_t, std::size_t, _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_c_a_l_c_u_l_a_t_e_N_N_Z
│ │ │ │ │ - std::size_t > (std::size_t rows, std::size_t cols,
│ │ │ │ │ - std::size_t entries, const _M_M_H_e_a_d_e_r
│ │ │ │ │ - &header)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::istream & _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_o_p_e_r_a_t_o_r_>_>
│ │ │ │ │ - (std::istream &is, _N_u_m_e_r_i_c_W_r_a_p_p_e_r< T >
│ │ │ │ │ - &num)
│ │ │ │ │ -
│ │ │ │ │ - std::istream & _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_o_p_e_r_a_t_o_r_>_>
│ │ │ │ │ - (std::istream &is, _N_u_m_e_r_i_c_W_r_a_p_p_e_r<
│ │ │ │ │ - _P_a_t_t_e_r_n_D_u_m_m_y > &num)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - bool _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_o_p_e_r_a_t_o_r_<
│ │ │ │ │ - (const _I_n_d_e_x_D_a_t_a< T > &i1, const
│ │ │ │ │ - _I_n_d_e_x_D_a_t_a< T > &i2)
│ │ │ │ │ - LessThan operator.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::istream & _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_o_p_e_r_a_t_o_r_>_>
│ │ │ │ │ - (std::istream &is, _I_n_d_e_x_D_a_t_a< T >
│ │ │ │ │ - &data)
│ │ │ │ │ - Read _I_n_d_e_x_D_a_t_a from a stream.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::istream & _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_o_p_e_r_a_t_o_r_>_>
│ │ │ │ │ - (std::istream &is, _I_n_d_e_x_D_a_t_a<
│ │ │ │ │ - _N_u_m_e_r_i_c_W_r_a_p_p_e_r< std::complex< T > > >
│ │ │ │ │ - &data)
│ │ │ │ │ - Read _I_n_d_e_x_D_a_t_a from a stream.
│ │ │ │ │ - Specialization for std::complex.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::enable_if_t:: _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_c_o_n_j (const T
│ │ │ │ │ - value, T > &r)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::enable_if_t< _i_s___c_o_m_p_l_e_x< T >:: _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_c_o_n_j (const T
│ │ │ │ │ - value, T > &r)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:
│ │ │ │ │ - _r_e_a_d_S_p_a_r_s_e_E_n_t_r_i_e_s (_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x< T,
│ │ │ │ │ - A > &matrix, std::istream &file, std::
│ │ │ │ │ - size_t entries, const _M_M_H_e_a_d_e_r
│ │ │ │ │ - &mmHeader, const D &)
│ │ │ │ │ -
│ │ │ │ │ -std::tuple< std::string, std::string > _D_u_n_e_:_:_M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_s_p_l_i_t_F_i_l_e_n_a_m_e
│ │ │ │ │ - (const std::string &filename)
│ │ │ │ │ -
│ │ │ │ │ - void _D_u_n_e_:_:_m_m___r_e_a_d___h_e_a_d_e_r (std::size_t
│ │ │ │ │ - &rows, std::size_t &cols,
│ │ │ │ │ - _M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M_H_e_a_d_e_r &header,
│ │ │ │ │ - std::istream &istr, bool isVector)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_m_m___r_e_a_d___v_e_c_t_o_r___e_n_t_r_i_e_s (_D_u_n_e_:_:
│ │ │ │ │ - _B_l_o_c_k_V_e_c_t_o_r< T, A > &vector, std::
│ │ │ │ │ - size_t size, std::istream &istr, size_t
│ │ │ │ │ - lane)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_m_m___r_e_a_d___v_e_c_t_o_r___e_n_t_r_i_e_s (_D_u_n_e_:_:
│ │ │ │ │ - _B_l_o_c_k_V_e_c_t_o_r< Dune::FieldVector< T,
│ │ │ │ │ - entries >, A > &vector, std::size_t
│ │ │ │ │ - size, std::istream &istr, size_t lane)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_r_e_a_d_M_a_t_r_i_x_M_a_r_k_e_t (_D_u_n_e_:_:
│ │ │ │ │ - _B_l_o_c_k_V_e_c_t_o_r< T, A > &vector, std::
│ │ │ │ │ - istream &istr)
│ │ │ │ │ - Reads a _B_l_o_c_k_V_e_c_t_o_r from a matrix
│ │ │ │ │ - market file.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_r_e_a_d_M_a_t_r_i_x_M_a_r_k_e_t (_D_u_n_e_:_:
│ │ │ │ │ - _B_C_R_S_M_a_t_r_i_x< T, A > &matrix, std::
│ │ │ │ │ - istream &istr)
│ │ │ │ │ - Reads a sparse matrix from a matrix
│ │ │ │ │ - market file.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_m_m___p_r_i_n_t___e_n_t_r_y (const B &entry,
│ │ │ │ │ - std::size_t rowidx, std::size_t colidx,
│ │ │ │ │ - std::ostream &ostr)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_m_m___p_r_i_n_t___v_e_c_t_o_r___e_n_t_r_y (const V
│ │ │ │ │ - &entry, std::ostream &ostr, const std::
│ │ │ │ │ - integral_constant< int, 1 > &, size_t
│ │ │ │ │ - lane)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_m_m___p_r_i_n_t___v_e_c_t_o_r___e_n_t_r_y (const V
│ │ │ │ │ - &vector, std::ostream &ostr, const
│ │ │ │ │ - std::integral_constant< int, 0 > &,
│ │ │ │ │ - size_t lane)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::size_t _D_u_n_e_:_:_c_o_u_n_t_E_n_t_r_i_e_s (const _B_l_o_c_k_V_e_c_t_o_r<
│ │ │ │ │ - T, A > &vector)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - std::size_t _D_u_n_e_:_:_c_o_u_n_t_E_n_t_r_i_e_s (const _B_l_o_c_k_V_e_c_t_o_r<
│ │ │ │ │ - FieldVector< T, i >, A > &vector)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_w_r_i_t_e_M_a_t_r_i_x_M_a_r_k_e_t (const V
│ │ │ │ │ - &vector, std::ostream &ostr, const
│ │ │ │ │ - std::integral_constant< int, 0 > &)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_w_r_i_t_e_M_a_t_r_i_x_M_a_r_k_e_t (const M
│ │ │ │ │ - &matrix, std::ostream &ostr, const
│ │ │ │ │ - std::integral_constant< int, 1 > &)
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_w_r_i_t_e_M_a_t_r_i_x_M_a_r_k_e_t (const M
│ │ │ │ │ - &matrix, std::ostream &ostr)
│ │ │ │ │ - writes a _I_S_T_L matrix or vector to a
│ │ │ │ │ - stream in matrix market format.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_s_t_o_r_e_M_a_t_r_i_x_M_a_r_k_e_t (const M
│ │ │ │ │ - &matrix, std::string filename, int
│ │ │ │ │ - prec=_d_e_f_a_u_l_t___p_r_e_c_i_s_i_o_n)
│ │ │ │ │ - Stores a parallel matrix/vector in
│ │ │ │ │ - matrix market format in a file.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_s_t_o_r_e_M_a_t_r_i_x_M_a_r_k_e_t (const M
│ │ │ │ │ - &matrix, std::string filename, const
│ │ │ │ │ - _O_w_n_e_r_O_v_e_r_l_a_p_C_o_p_y_C_o_m_m_u_n_i_c_a_t_i_o_n< G, L >
│ │ │ │ │ - &comm, bool storeIndices=true, int
│ │ │ │ │ - prec=_d_e_f_a_u_l_t___p_r_e_c_i_s_i_o_n)
│ │ │ │ │ - Stores a parallel matrix/vector in
│ │ │ │ │ - matrix market format in a file.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_l_o_a_d_M_a_t_r_i_x_M_a_r_k_e_t (M &matrix,
│ │ │ │ │ - const std::string &filename,
│ │ │ │ │ - _O_w_n_e_r_O_v_e_r_l_a_p_C_o_p_y_C_o_m_m_u_n_i_c_a_t_i_o_n< G, L >
│ │ │ │ │ - &comm, bool readIndices=true)
│ │ │ │ │ - Load a parallel matrix/vector stored in
│ │ │ │ │ - matrix market format.
│ │ │ │ │ -
│ │ │ │ │ -template
│ │ │ │ │ - void _D_u_n_e_:_:_l_o_a_d_M_a_t_r_i_x_M_a_r_k_e_t (M &matrix,
│ │ │ │ │ - const std::string &filename)
│ │ │ │ │ - Load a matrix/vector stored in matrix
│ │ │ │ │ - market format.
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("richardson", [](auto tl, const auto &,
│ │ │ │ │ + const ParameterTree &config){ using D=typename Dune::TypeListElement< 1,
│ │ │ │ │ + decltype(tl)>::type;using R=typename Dune::TypeListElement< 2, decltype
│ │ │ │ │ + (tl)>::type;return std::make_shared< _R_i_c_h_a_r_d_s_o_n< D, R > >(config);})
│ │ │ │ │
│ │ │ │ │ -VVaarriiaabblleess
│ │ │ │ │ -static const int _D_u_n_e_:_:_d_e_f_a_u_l_t___p_r_e_c_i_s_i_o_n = -1
│ │ │ │ │ + _D_u_n_e_:_:_D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R ("ildl", _d_e_f_a_u_l_t_P_r_e_c_o_n_d_i_t_i_o_n_e_r_C_r_e_a_t_o_r<
│ │ │ │ │ + _D_u_n_e_:_:_S_e_q_I_L_D_L >())
│ │ │ │ │
│ │ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -Provides classes for reading and writing MatrixMarket Files with an extension
│ │ │ │ │ -for parallel matrices.
│ │ │ │ │ - Author
│ │ │ │ │ - Markus Blatt
│ │ │ │ │ +Define general preconditioner interface.
│ │ │ │ │ +Wrap the methods implemented by ISTL in this interface. However, the interface
│ │ │ │ │ +is extensible such that new preconditioners can be implemented and used with
│ │ │ │ │ +the solvers.
│ │ │ │ │ ===============================================================================
│ │ │ │ │ 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: matrixmarket.hh Source File
│ │ │ │ +dune-istl: preconditioners.hh Source File
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -74,1499 +74,840 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Go to the documentation of this file.
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5#ifndef DUNE_ISTL_MATRIXMARKET_HH
│ │ │ │ -
6#define DUNE_ISTL_MATRIXMARKET_HH
│ │ │ │ +
5#ifndef DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │ +
6#define DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
24#include <dune/common/exceptions.hh>
│ │ │ │ -
25#include <dune/common/fmatrix.hh>
│ │ │ │ -
26#include <dune/common/fvector.hh>
│ │ │ │ -
27#include <dune/common/hybridutilities.hh>
│ │ │ │ -
28#include <dune/common/stdstreams.hh>
│ │ │ │ -
29#include <dune/common/simd/simd.hh>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
64 namespace MatrixMarketImpl
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
15#include <dune/common/simd/simd.hh>
│ │ │ │ +
16#include <dune/common/parametertree.hh>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
73 template<
class O,
int c = -1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
75 public Preconditioner<typename O::domain_type, typename O::range_type>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
95 static std::string
str()
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
176 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
181 os<<
"%%MatrixMarket matrix coordinate ";
│ │ │ │ -
182 os<<mm_numeric_type<Simd::Scalar<typename Imp::BlockTraits<T>::field_type>>::str()<<
" general"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
186 template<
typename B,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
191 os<<
"%%MatrixMarket matrix array ";
│ │ │ │ -
192 os<<mm_numeric_type<Simd::Scalar<typename Imp::BlockTraits<B>::field_type>>::str()<<
" general"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
196 template<
typename T,
int j>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
201 os<<
"%%MatrixMarket matrix array ";
│ │ │ │ -
202 os<<mm_numeric_type<T>::str()<<
" general"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
206 template<
typename T,
int i,
int j>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
96 : inverse_operator_(inverse_operator)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
99 DUNE_THROW(InvalidStateException,
"User-supplied solver category does not match that of the given inverse operator");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
109 inverse_operator_.apply(v, copy, res);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
141 template<
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
165 : _A_(A), _n(n), _w(w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
184 :
SeqSSOR(A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
200 SeqSSOR (
const M& A,
const ParameterTree& configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
211 os<<
"%%MatrixMarket matrix array ";
│ │ │ │ -
212 os<<mm_numeric_type<T>::str()<<
" general"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
227 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
231 static_assert(IsNumber<T>::value,
"Only scalar entries are expected here!");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
233 static void print(std::ostream& os,
const M&)
│ │ │ │ -
│ │ │ │ -
235 os<<
"% ISTL_STRUCT blocked ";
│ │ │ │ -
236 os<<
"1 1"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
240 template<
typename T,
typename A,
int i>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
245 static void print(std::ostream& os,
const M&)
│ │ │ │ -
│ │ │ │ -
247 os<<
"% ISTL_STRUCT blocked ";
│ │ │ │ -
248 os<<i<<
" "<<1<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
252 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
256 static_assert(IsNumber<T>::value,
"Only scalar entries are expected here!");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
258 static void print(std::ostream& os,
const M&)
│ │ │ │ -
│ │ │ │ -
260 os<<
"% ISTL_STRUCT blocked ";
│ │ │ │ -
261 os<<
"1 1"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
265 template<
typename T,
typename A,
int i,
int j>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
270 static void print(std::ostream& os,
const M&)
│ │ │ │ -
│ │ │ │ -
272 os<<
"% ISTL_STRUCT blocked ";
│ │ │ │ -
273 os<<i<<
" "<<j<<std::endl;
│ │ │ │ -
│ │ │ │ +
209 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
217 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
219 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
230 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
261 template<
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
278 template<
typename T,
int i,
int j>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
283 static void print(std::ostream& os,
const M& m)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
287 template<
typename T,
int i>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
290 typedef FieldVector<T,i>
M;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
292 static void print(std::ostream& os,
const M& m)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
347 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
362 dverb<<buffer<<std::endl;
│ │ │ │ -
│ │ │ │ -
364 if(buffer!=
"%%MatrixMarket") {
│ │ │ │ -
│ │ │ │ -
366 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
285 : _A_(A), _n(n), _w(w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
304 :
SeqSOR(A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
320 SeqSOR (
const M& A,
const ParameterTree& configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
329 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
337 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
339 this->
template apply<true>(v,d);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
350 template<
bool forward>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
354 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
358 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
368 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
377 if(buffer !=
"matrix")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
380 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
394 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
401 if(buffer !=
"array")
│ │ │ │ -
│ │ │ │ -
403 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
410 if(buffer !=
"coordinate")
│ │ │ │ -
│ │ │ │ -
412 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
418 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
432 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
438 if(buffer !=
"integer")
│ │ │ │ -
│ │ │ │ -
440 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
449 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
456 if(buffer !=
"complex")
│ │ │ │ -
│ │ │ │ -
458 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
465 if(buffer !=
"pattern")
│ │ │ │ -
│ │ │ │ -
467 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
473 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
482 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
488 if(buffer !=
"general")
│ │ │ │ -
│ │ │ │ -
490 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
497 if(buffer !=
"hermitian")
│ │ │ │ -
│ │ │ │ -
499 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
505 if(buffer.size()==1) {
│ │ │ │ -
506 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
514 if(buffer !=
"symmetric")
│ │ │ │ -
│ │ │ │ -
516 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
523 if(buffer !=
"skew-symmetric")
│ │ │ │ -
│ │ │ │ -
525 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
531 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
536 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
539 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
545 template<std::
size_t brows, std::
size_t bcols>
│ │ │ │ -
546 std::tuple<std::size_t, std::size_t, std::size_t>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
549 std::size_t blockrows=rows/brows;
│ │ │ │ -
550 std::size_t blockcols=cols/bcols;
│ │ │ │ -
551 std::size_t blocksize=brows*bcols;
│ │ │ │ -
552 std::size_t blockentries=0;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
557 blockentries = entries/blocksize;
break;
│ │ │ │ -
│ │ │ │ -
559 blockentries = 2*entries/blocksize;
break;
│ │ │ │ -
│ │ │ │ -
561 blockentries = (2*entries-rows)/blocksize;
break;
│ │ │ │ -
│ │ │ │ -
563 blockentries = (2*entries-rows)/blocksize;
break;
│ │ │ │ -
│ │ │ │ -
565 throw Dune::NotImplemented();
│ │ │ │ -
│ │ │ │ -
567 return std::make_tuple(blockrows, blockcols, blockentries);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
398 template<
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
412 template<
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
436 : _A_(A), _n(n), _w(w)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
455 :
SeqJac(A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
471 SeqJac (
const M& A,
const ParameterTree& configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
480 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
488 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
490 for (
int i=0; i<_n; i++) {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
500 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
562 template <
class M,
class X,
class Y,
int l = 1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
595 Dinv_.resize(_A_.N());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
613 :
SeqDILU(A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
629 SeqDILU(
const M &A,
const ParameterTree &config)
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
646 return is>>data.number;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
675 template<
typename D,
int brows,
int bcols>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
687 static_assert(IsNumber<T>::value && brows==1 && bcols==1,
"Only scalar entries are expected here!");
│ │ │ │ -
688 for (
auto iter=matrix.
begin(); iter!= matrix.
end(); ++iter)
│ │ │ │ -
│ │ │ │ -
690 auto brow=iter.index();
│ │ │ │ -
691 for (
auto siter=rows[brow].begin(); siter != rows[brow].end(); ++siter)
│ │ │ │ -
692 (*iter)[siter->index] = siter->number;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
705 for (
auto iter=matrix.begin(); iter!= matrix.end(); ++iter)
│ │ │ │ -
│ │ │ │ -
707 for (
auto brow=iter.index()*brows,
│ │ │ │ -
708 browend=iter.index()*brows+brows;
│ │ │ │ -
709 brow<browend; ++brow)
│ │ │ │ -
│ │ │ │ -
711 for (
auto siter=rows[brow].begin(), send=rows[brow].end();
│ │ │ │ -
712 siter != send; ++siter)
│ │ │ │ -
713 (*iter)[siter->index/bcols][brow%brows][siter->index%bcols]=siter->number;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
639 virtual void pre([[maybe_unused]] X &x, [[maybe_unused]] Y &b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
648 virtual void apply(X &v,
const Y &d)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
664 virtual void post([[maybe_unused]] X &x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
696 template<
class M,
class X,
class Y,
int l=1>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
719 template<
int brows,
int bcols>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
727 :
SeqILU( A, 0, w, resort )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
733 std::enable_if_t<!is_complex<T>::value, T>
conj(
const T& r){
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
738 std::enable_if_t<is_complex<T>::value, T>
conj(
const T& r){
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
746 template<
typename B,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
755 template<
typename B,
int i,
int j,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
764 template<
typename T,
typename A,
typename D>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
766 std::istream& file, std::size_t entries,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
778 std::vector<std::set<IndexData<D> > > rows(matrix.
N()*brows);
│ │ │ │ -
│ │ │ │ -
780 auto readloop = [&] (
auto symmetryFixup) {
│ │ │ │ -
781 for(std::size_t i = 0; i < entries; ++i) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
787 assert(row/bcols<matrix.
N());
│ │ │ │ -
│ │ │ │ -
789 assert(data.
index/bcols<matrix.
M());
│ │ │ │ -
790 rows[row].insert(data);
│ │ │ │ -
│ │ │ │ -
792 symmetryFixup(row, data);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
799 readloop([](
auto...){});
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
802 readloop([&](
auto row,
auto data) {
│ │ │ │ -
│ │ │ │ -
804 data_sym.
index = row;
│ │ │ │ -
805 rows[data.index].insert(data_sym);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
809 readloop([&](
auto row,
auto data) {
│ │ │ │ -
│ │ │ │ -
811 data_sym.number = -data.number;
│ │ │ │ -
812 data_sym.
index = row;
│ │ │ │ -
813 rows[data.index].insert(data_sym);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
817 readloop([&](
auto row,
auto data) {
│ │ │ │ -
│ │ │ │ -
819 data_sym.number =
conj(data.number);
│ │ │ │ -
820 data_sym.
index = row;
│ │ │ │ -
821 rows[data.index].insert(data_sym);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
825 DUNE_THROW(Dune::NotImplemented,
│ │ │ │ -
826 "Only general, symmetric, skew-symmetric and hermitian is supported right now!");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
831 for(
typename Matrix::CreateIterator iter=matrix.
createbegin();
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
746 :
SeqILU(A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
763 SeqILU(
const M& A,
const ParameterTree& config)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
766 config.
get(
"resort", false))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
813 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
821 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
834 for(std::size_t brow=iter.index()*brows, browend=iter.index()*brows+brows;
│ │ │ │ -
835 brow<browend; ++brow)
│ │ │ │ -
│ │ │ │ -
837 typedef typename std::set<IndexData<D> >::const_iterator Siter;
│ │ │ │ -
838 for(Siter siter=rows[brow].begin(), send=rows[brow].end();
│ │ │ │ -
839 siter != send; ++siter, ++nnz)
│ │ │ │ -
840 iter.insert(siter->index/bcols);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
849 Setter(rows, matrix);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
843 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
852 inline std::tuple<std::string, std::string>
splitFilename(
const std::string& filename) {
│ │ │ │ -
853 std::size_t lastdot = filename.find_last_of(
".");
│ │ │ │ -
854 if(lastdot == std::string::npos)
│ │ │ │ -
855 return std::make_tuple(filename,
"");
│ │ │ │ -
│ │ │ │ -
857 std::string potentialFileExtension = filename.substr(lastdot);
│ │ │ │ -
858 if (potentialFileExtension ==
".mm" || potentialFileExtension ==
".mtx")
│ │ │ │ -
859 return std::make_tuple(filename.substr(0, lastdot), potentialFileExtension);
│ │ │ │ -
│ │ │ │ -
861 return std::make_tuple(filename,
"");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
875 using namespace MatrixMarketImpl;
│ │ │ │ -
│ │ │ │ -
877 if(!readMatrixMarketBanner(istr, header)) {
│ │ │ │ -
878 std::cerr <<
"First line was not a correct Matrix Market banner. Using default:\n"
│ │ │ │ -
879 <<
"%%MatrixMarket matrix coordinate real general"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
882 istr.seekg(0, std::ios::beg);
│ │ │ │ -
│ │ │ │ -
884 header.
type=array_type;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
899 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
905 for (
int i=0; size>0; ++i, --size)
│ │ │ │ -
906 istr>>Simd::lane(lane,vector[i]);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
909 template<
typename T,
typename A,
int entries>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
915 for(
int i=0; size>0; ++i, --size) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
918 Simd::lane(lane, vector[i/entries][i%entries])=val;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
854 std::unique_ptr< matrix_type >
ILU_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
859 std::vector< block_type, typename matrix_type::allocator_type >
inv_;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
877 template<
class X,
class Y>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
920 virtual void pre ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
929 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
934 using namespace MatrixMarketImpl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
937 std::size_t rows, cols;
│ │ │ │ -
│ │ │ │ -
939 if(cols!=Simd::lanes<field_type>()) {
│ │ │ │ -
940 if(Simd::lanes<field_type>() == 1)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
946 if(header.type!=array_type)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
950 if constexpr (Dune::IsNumber<T>())
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
955 auto blocksize = dummy.size();
│ │ │ │ -
956 std::size_t size=rows/blocksize;
│ │ │ │ -
957 if(size*blocksize!=rows)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
963 istr.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
964 for(
size_t l=0;l<Simd::lanes<field_type>();++l){
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
975 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
979 using namespace MatrixMarketImpl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
983 if(!readMatrixMarketBanner(istr, header)) {
│ │ │ │ -
984 std::cerr <<
"First line was not a correct Matrix Market banner. Using default:\n"
│ │ │ │ -
985 <<
"%%MatrixMarket matrix coordinate real general"<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
988 istr.seekg(0, std::ios::beg);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
992 std::size_t rows, cols, entries;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
928 virtual void apply (X& v,
const Y& d)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
939 virtual void post ([[maybe_unused]] X& x)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
953 using D =
typename Dune::TypeListElement<1,
decltype(tl)>::type;
│ │ │ │ +
954 using R =
typename Dune::TypeListElement<2,
decltype(tl)>::type;
│ │ │ │ +
955 return std::make_shared<Richardson<D,R>>(config);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
969 template<
class M,
class X,
class Y >
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1003 :
SeqILDL(A->getmat(), configuration)
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1008 std::size_t nnz, blockrows, blockcols;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1011 constexpr int brows = mm_multipliers<Matrix>::rows;
│ │ │ │ -
1012 constexpr int bcols = mm_multipliers<Matrix>::cols;
│ │ │ │ -
│ │ │ │ -
1014 std::tie(blockrows, blockcols, nnz) = calculateNNZ<brows, bcols>(rows, cols, entries, header);
│ │ │ │ -
│ │ │ │ -
1016 istr.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1019 matrix.
setSize(blockrows, blockcols, nnz);
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
1022 if(header.type==array_type)
│ │ │ │ -
1023 DUNE_THROW(Dune::NotImplemented,
"Array format currently not supported for matrices!");
│ │ │ │ -
│ │ │ │ -
1025 readSparseEntries(matrix, istr, entries, header, NumericWrapper<typename Matrix::field_type>());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1029 template<
typename B>
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1035 if constexpr (IsNumber<B>())
│ │ │ │ -
1036 ostr << rowidx <<
" " << colidx <<
" " << entry << std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1039 for (
auto row=entry.begin(); row != entry.end(); ++row, ++rowidx) {
│ │ │ │ -
│ │ │ │ -
1041 for (
auto col = row->begin();
col != row->end(); ++
col, ++coli)
│ │ │ │ -
1042 ostr<< rowidx<<
" "<<coli<<
" "<<*
col<<std::endl;
│ │ │ │ +
│ │ │ │ +
1031 : decomposition_( A.N(), A.M(),
matrix_type::random ),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1035 for(
auto i = A.begin(), iend = A.end(); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
1037 const auto &A_i = *i;
│ │ │ │ +
1038 const auto ij = A_i.find( i.index() );
│ │ │ │ +
1039 if( ij != A_i.end() )
│ │ │ │ +
1040 decomposition_.setrowsize( i.index(), ij.offset()+1 );
│ │ │ │ +
│ │ │ │ +
1042 DUNE_THROW(
ISTLError,
"diagonal entry missing" );
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1048 template<
typename V>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1050 const std::integral_constant<int,1>&,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1053 ostr<<Simd::lane(lane,entry)<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
1044 decomposition_.endrowsizes();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1047 for(
auto i = A.begin(), iend = A.end(); i != iend; ++i )
│ │ │ │ +
│ │ │ │ +
1049 const auto &A_i = *i;
│ │ │ │ +
1050 for(
auto ij = A_i.begin(); ij.index() < i.index() ; ++ij )
│ │ │ │ +
1051 decomposition_.addindex( i.index(), ij.index() );
│ │ │ │ +
1052 decomposition_.addindex( i.index(), i.index() );
│ │ │ │ +
│ │ │ │ +
1054 decomposition_.endindices();
│ │ │ │
│ │ │ │ -
│ │ │ │ -
1057 template<
typename V>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1059 const std::integral_constant<int,0>&,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1062 using namespace MatrixMarketImpl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1065 const int isnumeric = mm_numeric_type<Simd::Scalar<typename V::block_type>>::is_numeric;
│ │ │ │ -
1066 typedef typename V::const_iterator VIter;
│ │ │ │ -
│ │ │ │ -
1068 for(VIter i=vector.begin(); i != vector.end(); ++i)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1071 std::integral_constant<int,isnumeric>(),
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1075 template<
typename T,
typename A>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1078 return vector.size();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1081 template<
typename T,
typename A,
int i>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1084 return vector.size()*i;
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1058 for(
auto row = decomposition_.begin(), rowend = decomposition_.end(); row != rowend; ++row, ++i )
│ │ │ │ +
│ │ │ │ +
1060 auto ij = i->begin();
│ │ │ │ +
1061 for(
auto col = row->begin(), colend = row->end();
col != colend; ++
col, ++ij )
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1070 void pre ([[maybe_unused]] X &x, [[maybe_unused]] Y &b)
override
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1074 void apply ( X &v,
const Y &d )
override
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1081 void post ([[maybe_unused]] X &x)
override
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
1088 template<
typename V>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1090 const std::integral_constant<int,0>&)
│ │ │ │ -
│ │ │ │ -
1092 using namespace MatrixMarketImpl;
│ │ │ │ -
1093 typedef typename V::field_type field_type;
│ │ │ │ -
│ │ │ │ -
1095 ostr<<
countEntries(vector)<<
" "<<Simd::lanes<field_type>()<<std::endl;
│ │ │ │ -
1096 const int isnumeric = mm_numeric_type<Simd::Scalar<V>>::is_numeric;
│ │ │ │ -
1097 for(
size_t l=0;l<Simd::lanes<field_type>(); ++l){
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1103 template<
typename M>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1106 const std::integral_constant<int,1>&)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1112 typedef typename M::const_iterator riterator;
│ │ │ │ -
1113 typedef typename M::ConstColIterator citerator;
│ │ │ │ -
1114 for(riterator row=matrix.begin(); row != matrix.end(); ++row)
│ │ │ │ -
1115 for(citerator
col = row->begin();
col != row->end(); ++
col)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1125 template<
typename M>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1129 using namespace MatrixMarketImpl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1132 mm_header_printer<M>::print(ostr);
│ │ │ │ -
1133 mm_block_structure_header<M>::print(ostr,matrix);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1150 template<
typename M>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1152 std::string filename,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1156 std::string rfilename;
│ │ │ │ -
│ │ │ │ -
1158 if (extension !=
"") {
│ │ │ │ -
1159 rfilename = pureFilename + extension;
│ │ │ │ -
1160 file.open(rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1162 DUNE_THROW(IOError,
"Could not open file for storage: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1166 rfilename = pureFilename +
".mm";
│ │ │ │ -
1167 file.open(rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1169 DUNE_THROW(IOError,
"Could not open file for storage: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1172 file.setf(std::ios::scientific,std::ios::floatfield);
│ │ │ │ -
│ │ │ │ -
1174 file.precision(prec);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1194 template<
typename M,
typename G,
typename L>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1196 std::string filename,
│ │ │ │ -
│ │ │ │ -
1198 bool storeIndices=
true,
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1205 std::string rfilename;
│ │ │ │ -
│ │ │ │ -
1207 if (extension !=
"") {
│ │ │ │ -
1208 rfilename = pureFilename +
"_" + std::to_string(rank) + extension;
│ │ │ │ -
1209 file.open(rfilename.c_str());
│ │ │ │ -
1210 dverb<< rfilename <<std::endl;
│ │ │ │ -
│ │ │ │ -
1212 DUNE_THROW(IOError,
"Could not open file for storage: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1216 rfilename = pureFilename +
"_" + std::to_string(rank) +
".mm";
│ │ │ │ -
1217 file.open(rfilename.c_str());
│ │ │ │ -
1218 dverb<< rfilename <<std::endl;
│ │ │ │ -
│ │ │ │ -
1220 DUNE_THROW(IOError,
"Could not open file for storage: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1222 file.setf(std::ios::scientific,std::ios::floatfield);
│ │ │ │ -
│ │ │ │ -
1224 file.precision(prec);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1232 rfilename = pureFilename +
"_" + std::to_string(rank) +
".idx";
│ │ │ │ -
1233 file.open(rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1235 DUNE_THROW(IOError,
"Could not open file for storage: " << rfilename.c_str());
│ │ │ │ -
1236 file.setf(std::ios::scientific,std::ios::floatfield);
│ │ │ │ -
│ │ │ │ -
1238 typedef typename IndexSet::const_iterator Iterator;
│ │ │ │ -
1239 for(Iterator iter = comm.
indexSet().begin();
│ │ │ │ -
1240 iter != comm.
indexSet().end(); ++iter) {
│ │ │ │ -
1241 file << iter->global()<<
" "<<(std::size_t)iter->local()<<
" "
│ │ │ │ -
1242 <<(int)iter->local().attribute()<<
" "<<(int)iter->local().isPublic()<<std::endl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1245 file<<
"neighbours:";
│ │ │ │ -
1246 const std::set<int>& neighbours=comm.
remoteIndices().getNeighbours();
│ │ │ │ -
1247 typedef std::set<int>::const_iterator SIter;
│ │ │ │ -
1248 for(SIter neighbour=neighbours.begin(); neighbour != neighbours.end(); ++neighbour) {
│ │ │ │ -
1249 file<<
" "<< *neighbour;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1268 template<
typename M,
typename G,
typename L>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1270 const std::string& filename,
│ │ │ │ -
│ │ │ │ -
1272 bool readIndices=
true)
│ │ │ │ -
│ │ │ │ -
1274 using namespace MatrixMarketImpl;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1277 typedef typename LocalIndexT::Attribute Attribute;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1282 std::string rfilename;
│ │ │ │ -
│ │ │ │ -
1284 if (extension !=
"") {
│ │ │ │ -
1285 rfilename = pureFilename +
"_" + std::to_string(rank) + extension;
│ │ │ │ -
1286 file.open(rfilename.c_str(), std::ios::in);
│ │ │ │ -
1287 dverb<< rfilename <<std::endl;
│ │ │ │ -
│ │ │ │ -
1289 DUNE_THROW(IOError,
"Could not open file: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1293 rfilename = pureFilename +
"_" + std::to_string(rank) +
".mm";
│ │ │ │ -
1294 file.open(rfilename.c_str(), std::ios::in);
│ │ │ │ -
│ │ │ │ -
1296 rfilename = pureFilename +
"_" + std::to_string(rank) +
".mtx";
│ │ │ │ -
1297 file.open(rfilename.c_str(), std::ios::in);
│ │ │ │ -
1298 dverb<< rfilename <<std::endl;
│ │ │ │ -
│ │ │ │ -
1300 DUNE_THROW(IOError,
"Could not open file: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1311 IndexSet& pis=comm.pis;
│ │ │ │ -
1312 rfilename = pureFilename +
"_" + std::to_string(rank) +
".idx";
│ │ │ │ -
1313 file.open(rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1315 DUNE_THROW(IOError,
"Could not open file: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1317 DUNE_THROW(InvalidIndexSetState,
"Index set is not empty!");
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1320 while(!file.eof() && file.peek()!=
'n') {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1329 pis.add(g,LocalIndexT(l,Attribute(c),b));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1337 if(s!=
"neighbours:")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1340 while(!file.eof()) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1346 comm.ri.setNeighbours(nb);
│ │ │ │ -
│ │ │ │ -
1348 comm.ri.template rebuild<false>();
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1363 template<
typename M>
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1365 const std::string& filename)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1368 std::string rfilename;
│ │ │ │ -
│ │ │ │ -
1370 if (extension !=
"") {
│ │ │ │ -
1371 rfilename = pureFilename + extension;
│ │ │ │ -
1372 file.open(rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
1374 DUNE_THROW(IOError,
"Could not open file: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
1378 rfilename = pureFilename +
".mm";
│ │ │ │ -
1379 file.open(rfilename.c_str(), std::ios::in);
│ │ │ │ -
│ │ │ │ -
1381 rfilename = pureFilename +
".mtx";
│ │ │ │ -
1382 file.open(rfilename.c_str(), std::ios::in);
│ │ │ │ -
│ │ │ │ -
1384 DUNE_THROW(IOError,
"Could not open file: " << rfilename.c_str());
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
Classes providing communication interfaces for overlapping Schwarz methods.
│ │ │ │ -
This file implements a vector space as a tensor product of a given vector space. The number of compon...
│ │ │ │ -
Implementation of the BCRSMatrix class.
│ │ │ │ -
Some handy generic functions for ISTL matrices.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.
│ │ │ │ +
│ │ │ │ +
#define DUNE_REGISTER_PRECONDITIONER(name,...)
Definition solverregistry.hh:16
│ │ │ │ +
Incomplete LDL decomposition.
│ │ │ │ +
Define general, extensible interface for inverse operators.
│ │ │ │ +
│ │ │ │ +
The incomplete LU factorization kernels.
│ │ │ │ +
The diagonal incomplete LU factorization kernels.
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Some handy generic functions for ISTL matrices.
│ │ │ │
Col col
Definition matrixmatrix.hh:351
│ │ │ │ -
auto countNonZeros(const M &, typename std::enable_if_t< Dune::IsNumber< M >::value > *sfinae=nullptr)
Get the number of nonzero fields in the matrix.
Definition matrixutils.hh:119
│ │ │ │ -
void readMatrixMarket(Dune::BlockVector< T, A > &vector, std::istream &istr)
Reads a BlockVector from a matrix market file.
Definition matrixmarket.hh:930
│ │ │ │ -
void storeMatrixMarket(const M &matrix, std::string filename, int prec=default_precision)
Stores a parallel matrix/vector in matrix market format in a file.
Definition matrixmarket.hh:1151
│ │ │ │ -
void loadMatrixMarket(M &matrix, const std::string &filename, OwnerOverlapCopyCommunication< G, L > &comm, bool readIndices=true)
Load a parallel matrix/vector stored in matrix market format.
Definition matrixmarket.hh:1269
│ │ │ │ -
std::size_t countEntries(const BlockVector< T, A > &vector)
Definition matrixmarket.hh:1076
│ │ │ │ -
void writeMatrixMarket(const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &)
Definition matrixmarket.hh:1089
│ │ │ │ -
void mm_print_vector_entry(const V &entry, std::ostream &ostr, const std::integral_constant< int, 1 > &, size_t lane)
Definition matrixmarket.hh:1049
│ │ │ │ -
static const int default_precision
Definition matrixmarket.hh:1138
│ │ │ │ -
void mm_read_vector_entries(Dune::BlockVector< T, A > &vector, std::size_t size, std::istream &istr, size_t lane)
Definition matrixmarket.hh:900
│ │ │ │ -
void mm_read_header(std::size_t &rows, std::size_t &cols, MatrixMarketImpl::MMHeader &header, std::istream &istr, bool isVector)
Definition matrixmarket.hh:871
│ │ │ │ -
void mm_print_entry(const B &entry, std::size_t rowidx, std::size_t colidx, std::ostream &ostr)
Definition matrixmarket.hh:1030
│ │ │ │ -
│ │ │ │ +
void bsorb(const M &A, X &x, const Y &b, const K &w)
SSOR step.
Definition gsetc.hh:646
│ │ │ │ +
void dbjac(const M &A, X &x, const Y &b, const K &w)
Jacobi step.
Definition gsetc.hh:658
│ │ │ │ +
void bsorf(const M &A, X &x, const Y &b, const K &w)
SOR step.
Definition gsetc.hh:634
│ │ │ │
Definition allocator.hh:11
│ │ │ │ -
std::tuple< std::size_t, std::size_t, std::size_t > calculateNNZ(std::size_t rows, std::size_t cols, std::size_t entries, const MMHeader &header)
Definition matrixmarket.hh:547
│ │ │ │ -
bool operator<(const IndexData< T > &i1, const IndexData< T > &i2)
LessThan operator.
Definition matrixmarket.hh:630
│ │ │ │ -
LineType
Definition matrixmarket.hh:296
│ │ │ │ -
@ DATA
Definition matrixmarket.hh:296
│ │ │ │ -
@ MM_HEADER
Definition matrixmarket.hh:296
│ │ │ │ -
@ MM_ISTLSTRUCT
Definition matrixmarket.hh:296
│ │ │ │ -
bool readMatrixMarketBanner(std::istream &file, MMHeader &mmHeader)
Definition matrixmarket.hh:353
│ │ │ │ -
void readSparseEntries(Dune::BCRSMatrix< T, A > &matrix, std::istream &file, std::size_t entries, const MMHeader &mmHeader, const D &)
Definition matrixmarket.hh:765
│ │ │ │ -
MM_TYPE
Definition matrixmarket.hh:299
│ │ │ │ -
@ array_type
Definition matrixmarket.hh:299
│ │ │ │ -
@ coordinate_type
Definition matrixmarket.hh:299
│ │ │ │ -
@ unknown_type
Definition matrixmarket.hh:299
│ │ │ │ -
std::istream & operator>>(std::istream &is, NumericWrapper< T > &num)
Definition matrixmarket.hh:614
│ │ │ │ -
void skipComments(std::istream &file)
Definition matrixmarket.hh:339
│ │ │ │ -
bool lineFeed(std::istream &file)
Definition matrixmarket.hh:315
│ │ │ │ -
@ MM_MAX_LINE_LENGTH
Definition matrixmarket.hh:297
│ │ │ │ -
MM_STRUCTURE
Definition matrixmarket.hh:303
│ │ │ │ -
@ skew_symmetric
Definition matrixmarket.hh:303
│ │ │ │ -
@ general
Definition matrixmarket.hh:303
│ │ │ │ -
@ hermitian
Definition matrixmarket.hh:303
│ │ │ │ -
@ unknown_structure
Definition matrixmarket.hh:303
│ │ │ │ -
@ symmetric
Definition matrixmarket.hh:303
│ │ │ │ -
MM_CTYPE
Definition matrixmarket.hh:301
│ │ │ │ -
@ unknown_ctype
Definition matrixmarket.hh:301
│ │ │ │ -
@ pattern
Definition matrixmarket.hh:301
│ │ │ │ -
@ complex_type
Definition matrixmarket.hh:301
│ │ │ │ -
@ double_type
Definition matrixmarket.hh:301
│ │ │ │ -
@ integer_type
Definition matrixmarket.hh:301
│ │ │ │ -
std::enable_if_t<!is_complex< T >::value, T > conj(const T &r)
Definition matrixmarket.hh:733
│ │ │ │ -
std::tuple< std::string, std::string > splitFilename(const std::string &filename)
Definition matrixmarket.hh:852
│ │ │ │ -
A sparse block matrix with compressed row storage.
Definition bcrsmatrix.hh:466
│ │ │ │ -
Iterator begin()
Get iterator to first row.
Definition bcrsmatrix.hh:671
│ │ │ │ -
Iterator end()
Get iterator to one beyond last row.
Definition bcrsmatrix.hh:677
│ │ │ │ -
CreateIterator createend()
get create iterator pointing to one after the last block
Definition bcrsmatrix.hh:1100
│ │ │ │ -
size_type M() const
number of columns (counted in blocks)
Definition bcrsmatrix.hh:2007
│ │ │ │ -
CreateIterator createbegin()
get initial create iterator
Definition bcrsmatrix.hh:1094
│ │ │ │ -
size_type N() const
number of rows (counted in blocks)
Definition bcrsmatrix.hh:2001
│ │ │ │ -
void setBuildMode(BuildMode bm)
Sets the build mode of the matrix.
Definition bcrsmatrix.hh:830
│ │ │ │ -
void setSize(size_type rows, size_type columns, size_type nnz=0)
Set the size of the matrix.
Definition bcrsmatrix.hh:858
│ │ │ │ -
A vector of blocks with memory management.
Definition bvector.hh:392
│ │ │ │ -
void resize(size_type size)
Resize the vector.
Definition bvector.hh:496
│ │ │ │ -
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition bvector.hh:398
│ │ │ │ -
A generic dynamic dense matrix.
Definition matrix.hh:561
│ │ │ │ -
Helper metaprogram to get the matrix market string representation of the numeric type.
Definition matrixmarket.hh:76
│ │ │ │ -
@ is_numeric
Whether T is a supported numeric type.
Definition matrixmarket.hh:81
│ │ │ │ -
static std::string str()
Definition matrixmarket.hh:95
│ │ │ │ -
static std::string str()
Definition matrixmarket.hh:111
│ │ │ │ -
static std::string str()
Definition matrixmarket.hh:127
│ │ │ │ -
static std::string str()
Definition matrixmarket.hh:143
│ │ │ │ -
static std::string str()
Definition matrixmarket.hh:159
│ │ │ │ -
Meta program to write the correct Matrix Market header.
Definition matrixmarket.hh:174
│ │ │ │ -
static void print(std::ostream &os)
Definition matrixmarket.hh:179
│ │ │ │ -
static void print(std::ostream &os)
Definition matrixmarket.hh:189
│ │ │ │ -
static void print(std::ostream &os)
Definition matrixmarket.hh:199
│ │ │ │ -
static void print(std::ostream &os)
Definition matrixmarket.hh:209
│ │ │ │ -
Metaprogram for writing the ISTL block structure header.
Definition matrixmarket.hh:225
│ │ │ │ -
static void print(std::ostream &os, const M &)
Definition matrixmarket.hh:233
│ │ │ │ -
BlockVector< T, A > M
Definition matrixmarket.hh:230
│ │ │ │ -
BlockVector< FieldVector< T, i >, A > M
Definition matrixmarket.hh:243
│ │ │ │ -
static void print(std::ostream &os, const M &)
Definition matrixmarket.hh:245
│ │ │ │ -
BCRSMatrix< T, A > M
Definition matrixmarket.hh:255
│ │ │ │ -
static void print(std::ostream &os, const M &)
Definition matrixmarket.hh:258
│ │ │ │ -
BCRSMatrix< FieldMatrix< T, i, j >, A > M
Definition matrixmarket.hh:268
│ │ │ │ -
static void print(std::ostream &os, const M &)
Definition matrixmarket.hh:270
│ │ │ │ -
static void print(std::ostream &os, const M &m)
Definition matrixmarket.hh:283
│ │ │ │ -
FieldMatrix< T, i, j > M
Definition matrixmarket.hh:281
│ │ │ │ -
static void print(std::ostream &os, const M &m)
Definition matrixmarket.hh:292
│ │ │ │ -
FieldVector< T, i > M
Definition matrixmarket.hh:290
│ │ │ │ -
Definition matrixmarket.hh:306
│ │ │ │ -
MM_STRUCTURE structure
Definition matrixmarket.hh:312
│ │ │ │ -
MM_TYPE type
Definition matrixmarket.hh:310
│ │ │ │ -
MMHeader()
Definition matrixmarket.hh:307
│ │ │ │ -
MM_CTYPE ctype
Definition matrixmarket.hh:311
│ │ │ │ -
Definition matrixmarket.hh:578
│ │ │ │ -
std::size_t index
Definition matrixmarket.hh:579
│ │ │ │ -
a wrapper class of numeric values.
Definition matrixmarket.hh:595
│ │ │ │ -
T number
Definition matrixmarket.hh:596
│ │ │ │ -
Utility class for marking the pattern type of the MatrixMarket matrices.
Definition matrixmarket.hh:607
│ │ │ │ -
Functor to the data values of the matrix.
Definition matrixmarket.hh:677
│ │ │ │ -
void operator()(const std::vector< std::set< IndexData< D > > > &rows, BCRSMatrix< T > &matrix)
Sets the matrix values.
Definition matrixmarket.hh:684
│ │ │ │ -
void operator()(const std::vector< std::set< IndexData< D > > > &rows, BCRSMatrix< FieldMatrix< T, brows, bcols > > &matrix)
Sets the matrix values.
Definition matrixmarket.hh:702
│ │ │ │ -
void operator()(const std::vector< std::set< IndexData< PatternDummy > > > &rows, M &matrix)
Definition matrixmarket.hh:723
│ │ │ │ -
Definition matrixmarket.hh:728
│ │ │ │ -
Definition matrixmarket.hh:744
│ │ │ │ -
Definition matrixmarket.hh:868
│ │ │ │ -
Definition matrixutils.hh:27
│ │ │ │ -
Test whether a type is an ISTL Matrix.
Definition matrixutils.hh:504
│ │ │ │ -
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition owneroverlapcopy.hh:174
│ │ │ │ -
const ParallelIndexSet & indexSet() const
Get the underlying parallel index set.
Definition owneroverlapcopy.hh:462
│ │ │ │ -
const Communication< MPI_Comm > & communicator() const
Definition owneroverlapcopy.hh:299
│ │ │ │ -
const RemoteIndices & remoteIndices() const
Get the underlying remote indices.
Definition owneroverlapcopy.hh:471
│ │ │ │ -
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition owneroverlapcopy.hh:449
│ │ │ │ +
void bildl_decompose(Matrix &A)
compute ILDL decomposition of a symmetric matrix A
Definition ildl.hh:88
│ │ │ │ +
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)
Definition dependency.hh:293
│ │ │ │ +
void bildl_backsolve(const Matrix &A, X &v, const Y &d, bool isLowerTriangular=false)
Definition ildl.hh:149
│ │ │ │ +
void blockDILUDecomposition(M &A, std::vector< typename M::block_type > &Dinv_)
Definition dilu.hh:51
│ │ │ │ +
void blockDILUBacksolve(const M &A, const std::vector< typename M::block_type > Dinv_, X &v, const Y &d)
Definition dilu.hh:107
│ │ │ │ +
void convertToCRS(const M &A, CRS &lower, CRS &upper, InvVector &inv)
convert ILU decomposition into CRS format for lower and upper triangular and inverse.
Definition ilu.hh:307
│ │ │ │ +
void blockILUBacksolve(const M &A, X &v, const Y &d)
LU backsolve with stored inverse.
Definition ilu.hh:94
│ │ │ │ +
void blockILU0Decomposition(M &A)
compute ILU decomposition of A. A is overwritten by its decomposition
Definition ilu.hh:33
│ │ │ │ +
void blockILUDecomposition(const M &A, int n, M &ILU)
Definition ilu.hh:167
│ │ │ │ +
compile-time parameter for block recursion depth
Definition gsetc.hh:45
│ │ │ │ +
a simple compressed row storage matrix class
Definition ilu.hh:259
│ │ │ │ +
derive error class from the base class in common
Definition istlexception.hh:19
│ │ │ │ +
static void check(const Matrix &mat)
Check whether the a matrix has diagonal values on blocklevel recursion levels.
Definition matrixutils.hh:53
│ │ │ │ +
A linear operator exporting itself in matrix form.
Definition operators.hh:111
│ │ │ │ +
Base class for matrix free definition of preconditioners.
Definition preconditioner.hh:33
│ │ │ │ +
Turns an InverseOperator into a Preconditioner.
Definition preconditioners.hh:76
│ │ │ │ +
O::range_type range_type
The range type of the preconditioner.
Definition preconditioners.hh:81
│ │ │ │ +
O::domain_type domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:79
│ │ │ │ +
virtual void post(domain_type &)
Clean up.
Definition preconditioners.hh:112
│ │ │ │ +
range_type::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:83
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:87
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:85
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:116
│ │ │ │ +
virtual void pre(domain_type &, range_type &)
Prepare the preconditioner.
Definition preconditioners.hh:102
│ │ │ │ +
InverseOperator2Preconditioner(InverseOperator &inverse_operator)
Construct the preconditioner from the solver.
Definition preconditioners.hh:95
│ │ │ │ +
O InverseOperator
type of the wrapped inverse operator
Definition preconditioners.hh:89
│ │ │ │ +
virtual void apply(domain_type &v, const range_type &d)
Apply one step of the preconditioner to the system A(v)=d.
Definition preconditioners.hh:105
│ │ │ │ +
Sequential SSOR preconditioner.
Definition preconditioners.hh:142
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:230
│ │ │ │ +
SeqSSOR(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:183
│ │ │ │ +
SeqSSOR(const M &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:200
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:234
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:151
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:153
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:147
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:145
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:217
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:209
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:149
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:155
│ │ │ │ +
SeqSSOR(const M &A, int n, real_field_type w)
Constructor.
Definition preconditioners.hh:164
│ │ │ │ +
Sequential SOR preconditioner.
Definition preconditioners.hh:262
│ │ │ │ +
SeqSOR(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:303
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:265
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:275
│ │ │ │ +
void apply(X &v, const Y &d)
Apply the preconditioner in a special direction.
Definition preconditioners.hh:351
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:267
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:368
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:329
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:273
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:372
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:337
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:269
│ │ │ │ +
SeqSOR(const M &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:320
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:271
│ │ │ │ +
SeqSOR(const M &A, int n, real_field_type w)
Constructor.
Definition preconditioners.hh:284
│ │ │ │ +
The sequential jacobian preconditioner.
Definition preconditioners.hh:413
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:500
│ │ │ │ +
SeqJac(const M &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:471
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:488
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:416
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:424
│ │ │ │ +
SeqJac(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:454
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:422
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:480
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:418
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:426
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:504
│ │ │ │ +
SeqJac(const M &A, int n, real_field_type w)
Constructor.
Definition preconditioners.hh:435
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:420
│ │ │ │ +
Sequential DILU preconditioner.
Definition preconditioners.hh:564
│ │ │ │ +
const bool wNotIdentity_
true if w != 1.0
Definition preconditioners.hh:681
│ │ │ │ +
typename X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:576
│ │ │ │ +
const real_field_type _w
The relaxation factor to use.
Definition preconditioners.hh:679
│ │ │ │ +
const M & _A_
The matrix we operate on.
Definition preconditioners.hh:677
│ │ │ │ +
SeqDILU(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:612
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:579
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:664
│ │ │ │ +
typename FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:581
│ │ │ │ +
M matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:567
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:571
│ │ │ │ +
typename matrix_type::block_type block_type
block type of matrix
Definition preconditioners.hh:569
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:648
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:639
│ │ │ │ +
SeqDILU(const M &A, real_field_type w)
Constructor.
Definition preconditioners.hh:589
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:669
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:573
│ │ │ │ +
SeqDILU(const M &A, const ParameterTree &config)
Constructor.
Definition preconditioners.hh:629
│ │ │ │ +
std::vector< block_type > Dinv_
Definition preconditioners.hh:675
│ │ │ │ +
Sequential ILU preconditioner.
Definition preconditioners.hh:697
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:843
│ │ │ │ +
SeqILU(const M &A, int n, real_field_type w, const bool resort=false)
Constructor.
Definition preconditioners.hh:777
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:813
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the preconditioner.
Definition preconditioners.hh:821
│ │ │ │ +
ILU::CRS< block_type, typename M::allocator_type > CRS
type of ILU storage
Definition preconditioners.hh:717
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:706
│ │ │ │ +
CRS lower_
The ILU(n) decomposition of the matrix. As storage a CRS structure is used.
Definition preconditioners.hh:857
│ │ │ │ +
const bool wNotIdentity_
true if w != 1.0
Definition preconditioners.hh:864
│ │ │ │ +
SeqILU(const M &A, const ParameterTree &config)
Constructor.
Definition preconditioners.hh:763
│ │ │ │ +
std::remove_const< M >::type matrix_type
The matrix type the preconditioner is for.
Definition preconditioners.hh:700
│ │ │ │ +
matrix_type::block_type block_type
block type of matrix
Definition preconditioners.hh:702
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:714
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:709
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:847
│ │ │ │ +
SeqILU(const M &A, real_field_type w, const bool resort=false)
Constructor.
Definition preconditioners.hh:726
│ │ │ │ +
const real_field_type w_
The relaxation factor to use.
Definition preconditioners.hh:862
│ │ │ │ +
SeqILU(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:745
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:704
│ │ │ │ +
std::vector< block_type, typename matrix_type::allocator_type > inv_
Definition preconditioners.hh:859
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:712
│ │ │ │ +
std::unique_ptr< matrix_type > ILU_
The ILU(n) decomposition of the matrix. As storage a BCRSMatrix is used.
Definition preconditioners.hh:854
│ │ │ │ +
CRS upper_
Definition preconditioners.hh:858
│ │ │ │ +
Richardson preconditioner.
Definition preconditioners.hh:878
│ │ │ │ +
X::field_type field_type
The field type of the preconditioner.
Definition preconditioners.hh:885
│ │ │ │ +
virtual SolverCategory::Category category() const
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:943
│ │ │ │ +
Y range_type
The range type of the preconditioner.
Definition preconditioners.hh:883
│ │ │ │ +
virtual void pre(X &x, Y &b)
Prepare the preconditioner.
Definition preconditioners.hh:920
│ │ │ │ +
Richardson(real_field_type w=1.0)
Constructor.
Definition preconditioners.hh:896
│ │ │ │ +
virtual void post(X &x)
Clean up.
Definition preconditioners.hh:939
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:889
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:887
│ │ │ │ +
Richardson(const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:911
│ │ │ │ +
X domain_type
The domain type of the preconditioner.
Definition preconditioners.hh:881
│ │ │ │ +
virtual void apply(X &v, const Y &d)
Apply the precondioner.
Definition preconditioners.hh:928
│ │ │ │ +
sequential ILDL preconditioner
Definition preconditioners.hh:972
│ │ │ │ +
SeqILDL(const matrix_type &A, const ParameterTree &config)
Constructor.
Definition preconditioners.hh:1018
│ │ │ │ +
SeqILDL(const matrix_type &A, real_field_type relax=real_field_type(1))
constructor
Definition preconditioners.hh:1030
│ │ │ │ +
X domain_type
domain type of the preconditioner
Definition preconditioners.hh:980
│ │ │ │ +
void post(X &x) override
Clean up.
Definition preconditioners.hh:1081
│ │ │ │ +
Y range_type
range type of the preconditioner
Definition preconditioners.hh:982
│ │ │ │ +
std::remove_const_t< M > matrix_type
type of matrix the preconditioner is for
Definition preconditioners.hh:978
│ │ │ │ +
void apply(X &v, const Y &d) override
Apply one step of the preconditioner to the system A(v)=d.
Definition preconditioners.hh:1074
│ │ │ │ +
FieldTraits< scalar_field_type >::real_type real_field_type
real scalar type underlying the field_type
Definition preconditioners.hh:988
│ │ │ │ +
SeqILDL(const std::shared_ptr< const AssembledLinearOperator< M, X, Y > > &A, const ParameterTree &configuration)
Constructor.
Definition preconditioners.hh:1002
│ │ │ │ +
void pre(X &x, Y &b) override
Prepare the preconditioner.
Definition preconditioners.hh:1070
│ │ │ │ +
Simd::Scalar< field_type > scalar_field_type
scalar type underlying the field_type
Definition preconditioners.hh:986
│ │ │ │ +
X::field_type field_type
field type of the preconditioner
Definition preconditioners.hh:984
│ │ │ │ +
SolverCategory::Category category() const override
Category of the preconditioner (see SolverCategory::Category)
Definition preconditioners.hh:1085
│ │ │ │ +
Statistics about the application of an inverse operator.
Definition solver.hh:50
│ │ │ │ +
Abstract base class for all solvers.
Definition solver.hh:101
│ │ │ │ +
Category
Definition solvercategory.hh:23
│ │ │ │ +
@ sequential
Category for sequential solvers.
Definition solvercategory.hh:25
│ │ │ │ +
static Category category(const OP &op, decltype(op.category()) *=nullptr)
Helperfunction to extract the solver category either from an enum, or from the newly introduced virtu...
Definition solvercategory.hh:34
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,1632 +1,1171 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -matrixmarket.hh
│ │ │ │ │ +preconditioners.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_MATRIXMARKET_HH
│ │ │ │ │ -6#define DUNE_ISTL_MATRIXMARKET_HH
│ │ │ │ │ +5#ifndef DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │ │ +6#define DUNE_ISTL_PRECONDITIONERS_HH
│ │ │ │ │ 7
│ │ │ │ │ -8#include
│ │ │ │ │ +8#include
│ │ │ │ │ 9#include
│ │ │ │ │ -10#include
│ │ │ │ │ -11#include
│ │ │ │ │ -12#include
│ │ │ │ │ -13#include
│ │ │ │ │ -14#include
│ │ │ │ │ -15#include
│ │ │ │ │ -16#include
│ │ │ │ │ -17#include
│ │ │ │ │ -18#include
│ │ │ │ │ -19#include
│ │ │ │ │ -20#include
│ │ │ │ │ -21#include
│ │ │ │ │ -22#include
│ │ │ │ │ -23
│ │ │ │ │ -24#include
│ │ │ │ │ -25#include
│ │ │ │ │ -26#include
│ │ │ │ │ -27#include
│ │ │ │ │ -28#include
│ │ │ │ │ -29#include
│ │ │ │ │ -30
│ │ │ │ │ -31#include <_d_u_n_e_/_i_s_t_l_/_b_c_r_s_m_a_t_r_i_x_._h_h>
│ │ │ │ │ -32#include <_d_u_n_e_/_i_s_t_l_/_b_v_e_c_t_o_r_._h_h>
│ │ │ │ │ -33#include <_d_u_n_e_/_i_s_t_l_/_m_a_t_r_i_x_u_t_i_l_s_._h_h> // countNonZeros()
│ │ │ │ │ -34#include <_d_u_n_e_/_i_s_t_l_/_o_w_n_e_r_o_v_e_r_l_a_p_c_o_p_y_._h_h>
│ │ │ │ │ -35
│ │ │ │ │ -36namespace _D_u_n_e
│ │ │ │ │ -37{
│ │ │ │ │ -38
│ │ │ │ │ -_6_4 namespace MatrixMarketImpl
│ │ │ │ │ -65 {
│ │ │ │ │ -75 template
│ │ │ │ │ -_7_6 struct _m_m___n_u_m_e_r_i_c___t_y_p_e {
│ │ │ │ │ -77 enum {
│ │ │ │ │ -81 _i_s___n_u_m_e_r_i_c=false
│ │ │ │ │ -_8_2 };
│ │ │ │ │ -83 };
│ │ │ │ │ -84
│ │ │ │ │ -85 template<>
│ │ │ │ │ -_8_6 struct _m_m___n_u_m_e_r_i_c___t_y_p_e
│ │ │ │ │ -87 {
│ │ │ │ │ -88 enum {
│ │ │ │ │ -92 _i_s___n_u_m_e_r_i_c=true
│ │ │ │ │ -_9_3 };
│ │ │ │ │ -94
│ │ │ │ │ -_9_5 static std::string _s_t_r()
│ │ │ │ │ -96 {
│ │ │ │ │ -97 return "integer";
│ │ │ │ │ -98 }
│ │ │ │ │ -99 };
│ │ │ │ │ -100
│ │ │ │ │ -101 template<>
│ │ │ │ │ -_1_0_2 struct _m_m___n_u_m_e_r_i_c___t_y_p_e
│ │ │ │ │ -103 {
│ │ │ │ │ -104 enum {
│ │ │ │ │ -108 _i_s___n_u_m_e_r_i_c=true
│ │ │ │ │ -_1_0_9 };
│ │ │ │ │ -110
│ │ │ │ │ -_1_1_1 static std::string _s_t_r()
│ │ │ │ │ -112 {
│ │ │ │ │ -113 return "real";
│ │ │ │ │ -114 }
│ │ │ │ │ -115 };
│ │ │ │ │ -116
│ │ │ │ │ -117 template<>
│ │ │ │ │ -_1_1_8 struct _m_m___n_u_m_e_r_i_c___t_y_p_e
│ │ │ │ │ -119 {
│ │ │ │ │ -120 enum {
│ │ │ │ │ -124 _i_s___n_u_m_e_r_i_c=true
│ │ │ │ │ -_1_2_5 };
│ │ │ │ │ -126
│ │ │ │ │ -_1_2_7 static std::string _s_t_r()
│ │ │ │ │ -128 {
│ │ │ │ │ -129 return "real";
│ │ │ │ │ -130 }
│ │ │ │ │ -131 };
│ │ │ │ │ -132
│ │ │ │ │ -133 template<>
│ │ │ │ │ -_1_3_4 struct _m_m___n_u_m_e_r_i_c___t_y_p_e<_s_t_d::complex >
│ │ │ │ │ -135 {
│ │ │ │ │ -136 enum {
│ │ │ │ │ -140 _i_s___n_u_m_e_r_i_c=true
│ │ │ │ │ -_1_4_1 };
│ │ │ │ │ -142
│ │ │ │ │ -_1_4_3 static std::string _s_t_r()
│ │ │ │ │ -144 {
│ │ │ │ │ -145 return "complex";
│ │ │ │ │ -146 }
│ │ │ │ │ -147 };
│ │ │ │ │ -148
│ │ │ │ │ -149 template<>
│ │ │ │ │ -_1_5_0 struct _m_m___n_u_m_e_r_i_c___t_y_p_e<_s_t_d::complex >
│ │ │ │ │ -151 {
│ │ │ │ │ -152 enum {
│ │ │ │ │ -156 _i_s___n_u_m_e_r_i_c=true
│ │ │ │ │ -_1_5_7 };
│ │ │ │ │ -158
│ │ │ │ │ -_1_5_9 static std::string _s_t_r()
│ │ │ │ │ -160 {
│ │ │ │ │ -161 return "complex";
│ │ │ │ │ -162 }
│ │ │ │ │ -163 };
│ │ │ │ │ -164
│ │ │ │ │ -173 template
│ │ │ │ │ -_1_7_4 struct _m_m___h_e_a_d_e_r___p_r_i_n_t_e_r;
│ │ │ │ │ -175
│ │ │ │ │ -176 template
│ │ │ │ │ -_1_7_7 struct _m_m___h_e_a_d_e_r___p_r_i_n_t_e_r<_B_C_R_S_M_a_t_r_i_x >
│ │ │ │ │ -178 {
│ │ │ │ │ -_1_7_9 static void _p_r_i_n_t(std::ostream& os)
│ │ │ │ │ -180 {
│ │ │ │ │ -181 os<<"%%MatrixMarket matrix coordinate ";
│ │ │ │ │ -182 os<::
│ │ │ │ │ -field_type>>::str()<<" general"<
│ │ │ │ │ -_1_8_7 struct _m_m___h_e_a_d_e_r___p_r_i_n_t_e_r<_B_l_o_c_k_V_e_c_t_o_r >
│ │ │ │ │ -188 {
│ │ │ │ │ -_1_8_9 static void _p_r_i_n_t(std::ostream& os)
│ │ │ │ │ -190 {
│ │ │ │ │ -191 os<<"%%MatrixMarket matrix array ";
│ │ │ │ │ -192 os<::
│ │ │ │ │ -field_type>>::str()<<" general"<
│ │ │ │ │ -_1_9_7 struct _m_m___h_e_a_d_e_r___p_r_i_n_t_e_r >
│ │ │ │ │ -198 {
│ │ │ │ │ -_1_9_9 static void _p_r_i_n_t(std::ostream& os)
│ │ │ │ │ -200 {
│ │ │ │ │ -201 os<<"%%MatrixMarket matrix array ";
│ │ │ │ │ -202 os<::str()<<" general"<
│ │ │ │ │ -_2_0_7 struct _m_m___h_e_a_d_e_r___p_r_i_n_t_e_r<_F_i_e_l_d_M_a_t_r_i_x >
│ │ │ │ │ -208 {
│ │ │ │ │ -_2_0_9 static void _p_r_i_n_t(std::ostream& os)
│ │ │ │ │ -210 {
│ │ │ │ │ -211 os<<"%%MatrixMarket matrix array ";
│ │ │ │ │ -212 os<::str()<<" general"<
│ │ │ │ │ -_2_2_5 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r;
│ │ │ │ │ -226
│ │ │ │ │ -227 template
│ │ │ │ │ -_2_2_8 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r<_B_l_o_c_k_V_e_c_t_o_r >
│ │ │ │ │ -229 {
│ │ │ │ │ -_2_3_0 typedef _B_l_o_c_k_V_e_c_t_o_r_<_T_,_A_> _M;
│ │ │ │ │ -231 static_assert(IsNumber::value, "Only scalar entries are expected
│ │ │ │ │ -here!");
│ │ │ │ │ +10#include
│ │ │ │ │ +11#include
│ │ │ │ │ +12#include
│ │ │ │ │ +13#include
│ │ │ │ │ +14
│ │ │ │ │ +15#include
│ │ │ │ │ +16#include
│ │ │ │ │ +17
│ │ │ │ │ +18#include <_d_u_n_e_/_i_s_t_l_/_s_o_l_v_e_r_r_e_g_i_s_t_r_y_._h_h>
│ │ │ │ │ +19#include "_p_r_e_c_o_n_d_i_t_i_o_n_e_r_._h_h"
│ │ │ │ │ +20#include "_s_o_l_v_e_r_._h_h"
│ │ │ │ │ +21#include "_s_o_l_v_e_r_c_a_t_e_g_o_r_y_._h_h"
│ │ │ │ │ +22#include "_i_s_t_l_e_x_c_e_p_t_i_o_n_._h_h"
│ │ │ │ │ +23#include "_m_a_t_r_i_x_u_t_i_l_s_._h_h"
│ │ │ │ │ +24#include "_g_s_e_t_c_._h_h"
│ │ │ │ │ +25#include "_d_i_l_u_._h_h"
│ │ │ │ │ +26#include "_i_l_d_l_._h_h"
│ │ │ │ │ +27#include "_i_l_u_._h_h"
│ │ │ │ │ +28
│ │ │ │ │ +29
│ │ │ │ │ +30namespace _D_u_n_e {
│ │ │ │ │ +73 template
│ │ │ │ │ +_7_4 class _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r :
│ │ │ │ │ +75 public _P_r_e_c_o_n_d_i_t_i_o_n_e_r
│ │ │ │ │ +76 {
│ │ │ │ │ +77 public:
│ │ │ │ │ +_7_9 typedef typename O::domain_type _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_8_1 typedef typename O::range_type _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_8_3 typedef typename range_type::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_5 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_7 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_9 typedef O _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r;
│ │ │ │ │ +90
│ │ │ │ │ +_9_5 _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_2_P_r_e_c_o_n_d_i_t_i_o_n_e_r(_I_n_v_e_r_s_e_O_p_e_r_a_t_o_r& inverse_operator)
│ │ │ │ │ +96 : inverse_operator_(inverse_operator)
│ │ │ │ │ +97 {
│ │ │ │ │ +98 if(c != -1 && _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_c_a_t_e_g_o_r_y(inverse_operator_) != c)
│ │ │ │ │ +99 DUNE_THROW(InvalidStateException, "User-supplied solver category does not
│ │ │ │ │ +match that of the given inverse operator");
│ │ │ │ │ +100 }
│ │ │ │ │ +101
│ │ │ │ │ +_1_0_2 virtual void _p_r_e(_d_o_m_a_i_n___t_y_p_e&,_r_a_n_g_e___t_y_p_e&)
│ │ │ │ │ +103 {}
│ │ │ │ │ +104
│ │ │ │ │ +_1_0_5 virtual void _a_p_p_l_y(_d_o_m_a_i_n___t_y_p_e& v, const _r_a_n_g_e___t_y_p_e& d)
│ │ │ │ │ +106 {
│ │ │ │ │ +107 _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r_R_e_s_u_l_t res;
│ │ │ │ │ +108 _r_a_n_g_e___t_y_p_e copy(d);
│ │ │ │ │ +109 inverse_operator_.apply(v, copy, res);
│ │ │ │ │ +110 }
│ │ │ │ │ +111
│ │ │ │ │ +_1_1_2 virtual void _p_o_s_t(_d_o_m_a_i_n___t_y_p_e&)
│ │ │ │ │ +113 {}
│ │ │ │ │ +114
│ │ │ │ │ +_1_1_6 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
│ │ │ │ │ +117 {
│ │ │ │ │ +118 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_c_a_t_e_g_o_r_y(inverse_operator_);
│ │ │ │ │ +119 }
│ │ │ │ │ +120
│ │ │ │ │ +121 private:
│ │ │ │ │ +122 _I_n_v_e_r_s_e_O_p_e_r_a_t_o_r& inverse_operator_;
│ │ │ │ │ +123 };
│ │ │ │ │ +124
│ │ │ │ │ +125 //=====================================================================
│ │ │ │ │ +126 // Implementation of this interface for sequential ISTL-preconditioners
│ │ │ │ │ +127 //=====================================================================
│ │ │ │ │ +128
│ │ │ │ │ +129
│ │ │ │ │ +141 template
│ │ │ │ │ +_1_4_2 class _S_e_q_S_S_O_R : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +143 public:
│ │ │ │ │ +_1_4_5 typedef M _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_1_4_7 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_1_4_9 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_1_5_1 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_1_5_3 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_1_5_5 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +156
│ │ │ │ │ +_1_6_4 _S_e_q_S_S_O_R (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +165 : _A_(A), _n(n), _w(w)
│ │ │ │ │ +166 {
│ │ │ │ │ +167 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +168 }
│ │ │ │ │ +169
│ │ │ │ │ +_1_8_3 _S_e_q_S_S_O_R (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +184 : _S_e_q_S_S_O_R(A->getmat(), configuration)
│ │ │ │ │ +185 {}
│ │ │ │ │ +186
│ │ │ │ │ +_2_0_0 _S_e_q_S_S_O_R (const M& A, const ParameterTree& configuration)
│ │ │ │ │ +201 : _S_e_q_S_S_O_R(A, configuration._g_e_t("iterations",1),
│ │ │ │ │ +configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation",1.0))
│ │ │ │ │ +202 {}
│ │ │ │ │ +203
│ │ │ │ │ +_2_0_9 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +210 {}
│ │ │ │ │ +211
│ │ │ │ │ +_2_1_7 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +218 {
│ │ │ │ │ +219 for (int i=0; i<_n; i++) {
│ │ │ │ │ +220 _b_s_o_r_f(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +221 _b_s_o_r_b(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +222 }
│ │ │ │ │ +223 }
│ │ │ │ │ +224
│ │ │ │ │ +_2_3_0 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +231 {}
│ │ │ │ │ 232
│ │ │ │ │ -_2_3_3 static void _p_r_i_n_t(std::ostream& os, const _M&)
│ │ │ │ │ -234 {
│ │ │ │ │ -235 os<<"% ISTL_STRUCT blocked ";
│ │ │ │ │ -236 os<<"1 1"<
│ │ │ │ │ -_2_4_1 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r<_B_l_o_c_k_V_e_c_t_o_r,A> >
│ │ │ │ │ -242 {
│ │ │ │ │ -_2_4_3 typedef _B_l_o_c_k_V_e_c_t_o_r_<_F_i_e_l_d_V_e_c_t_o_r_<_T_,_i_>,A> _M;
│ │ │ │ │ -244
│ │ │ │ │ -_2_4_5 static void _p_r_i_n_t(std::ostream& os, const _M&)
│ │ │ │ │ -246 {
│ │ │ │ │ -247 os<<"% ISTL_STRUCT blocked ";
│ │ │ │ │ -248 os<
│ │ │ │ │ -_2_5_3 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r<_B_C_R_S_M_a_t_r_i_x >
│ │ │ │ │ -254 {
│ │ │ │ │ -_2_5_5 typedef _B_C_R_S_M_a_t_r_i_x_<_T_,_A_> _M;
│ │ │ │ │ -256 static_assert(IsNumber::value, "Only scalar entries are expected
│ │ │ │ │ -here!");
│ │ │ │ │ -257
│ │ │ │ │ -_2_5_8 static void _p_r_i_n_t(std::ostream& os, const _M&)
│ │ │ │ │ -259 {
│ │ │ │ │ -260 os<<"% ISTL_STRUCT blocked ";
│ │ │ │ │ -261 os<<"1 1"<
│ │ │ │ │ -_2_6_6 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r<_B_C_R_S_M_a_t_r_i_x<_F_i_e_l_d_M_a_t_r_i_x,A> >
│ │ │ │ │ -267 {
│ │ │ │ │ -_2_6_8 typedef _B_C_R_S_M_a_t_r_i_x_<_F_i_e_l_d_M_a_t_r_i_x_<_T_,_i_,_j_>,A> _M;
│ │ │ │ │ -269
│ │ │ │ │ -_2_7_0 static void _p_r_i_n_t(std::ostream& os, const _M&)
│ │ │ │ │ -271 {
│ │ │ │ │ -272 os<<"% ISTL_STRUCT blocked ";
│ │ │ │ │ -273 os<());
│ │ │ │ │ +248
│ │ │ │ │ +249
│ │ │ │ │ +261 template
│ │ │ │ │ +_2_6_2 class _S_e_q_S_O_R : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +263 public:
│ │ │ │ │ +_2_6_5 typedef M _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_2_6_7 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_2_6_9 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_2_7_1 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_2_7_3 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_2_7_5 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ 276
│ │ │ │ │ -277
│ │ │ │ │ -278 template
│ │ │ │ │ -_2_7_9 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r<_F_i_e_l_d_M_a_t_r_i_x >
│ │ │ │ │ -280 {
│ │ │ │ │ -_2_8_1 typedef _F_i_e_l_d_M_a_t_r_i_x_<_T_,_i_,_j_> _M;
│ │ │ │ │ -282
│ │ │ │ │ -_2_8_3 static void _p_r_i_n_t(std::ostream& os, const _M& m)
│ │ │ │ │ -284 {}
│ │ │ │ │ -285 };
│ │ │ │ │ -286
│ │ │ │ │ -287 template
│ │ │ │ │ -_2_8_8 struct _m_m___b_l_o_c_k___s_t_r_u_c_t_u_r_e___h_e_a_d_e_r >
│ │ │ │ │ -289 {
│ │ │ │ │ -_2_9_0 typedef FieldVector _M;
│ │ │ │ │ -291
│ │ │ │ │ -_2_9_2 static void _p_r_i_n_t(std::ostream& os, const _M& m)
│ │ │ │ │ -293 {}
│ │ │ │ │ -294 };
│ │ │ │ │ -295
│ │ │ │ │ -_2_9_6 enum _L_i_n_e_T_y_p_e { _M_M___H_E_A_D_E_R, _M_M___I_S_T_L_S_T_R_U_C_T, _D_A_T_A };
│ │ │ │ │ -_2_9_7 enum { _M_M___M_A_X___L_I_N_E___L_E_N_G_T_H=1025 };
│ │ │ │ │ -298
│ │ │ │ │ -_2_9_9 enum _M_M___T_Y_P_E { _c_o_o_r_d_i_n_a_t_e___t_y_p_e, _a_r_r_a_y___t_y_p_e, _u_n_k_n_o_w_n___t_y_p_e };
│ │ │ │ │ -300
│ │ │ │ │ -_3_0_1 enum _M_M___C_T_Y_P_E { _i_n_t_e_g_e_r___t_y_p_e, _d_o_u_b_l_e___t_y_p_e, _c_o_m_p_l_e_x___t_y_p_e, _p_a_t_t_e_r_n,
│ │ │ │ │ -_u_n_k_n_o_w_n___c_t_y_p_e };
│ │ │ │ │ -302
│ │ │ │ │ -_3_0_3 enum _M_M___S_T_R_U_C_T_U_R_E { _g_e_n_e_r_a_l, _s_y_m_m_e_t_r_i_c, _s_k_e_w___s_y_m_m_e_t_r_i_c, _h_e_r_m_i_t_i_a_n,
│ │ │ │ │ -_u_n_k_n_o_w_n___s_t_r_u_c_t_u_r_e };
│ │ │ │ │ -304
│ │ │ │ │ -_3_0_5 struct _M_M_H_e_a_d_e_r
│ │ │ │ │ -306 {
│ │ │ │ │ -_3_0_7 _M_M_H_e_a_d_e_r()
│ │ │ │ │ -308 : _t_y_p_e(_c_o_o_r_d_i_n_a_t_e___t_y_p_e), _c_t_y_p_e(_d_o_u_b_l_e___t_y_p_e), _s_t_r_u_c_t_u_r_e(_g_e_n_e_r_a_l)
│ │ │ │ │ -309 {}
│ │ │ │ │ -_3_1_0 _M_M___T_Y_P_E _t_y_p_e;
│ │ │ │ │ -_3_1_1 _M_M___C_T_Y_P_E _c_t_y_p_e;
│ │ │ │ │ -_3_1_2 _M_M___S_T_R_U_C_T_U_R_E _s_t_r_u_c_t_u_r_e;
│ │ │ │ │ -313 };
│ │ │ │ │ -314
│ │ │ │ │ -_3_1_5 inline bool _l_i_n_e_F_e_e_d(std::istream& file)
│ │ │ │ │ -316 {
│ │ │ │ │ -317 char c;
│ │ │ │ │ -318 if(!file.eof())
│ │ │ │ │ -319 c=file.peek();
│ │ │ │ │ -320 else
│ │ │ │ │ -321 return false;
│ │ │ │ │ -322 // ignore whitespace
│ │ │ │ │ -323 while(c==' ')
│ │ │ │ │ -324 {
│ │ │ │ │ -325 file.get();
│ │ │ │ │ -326 if(file.eof())
│ │ │ │ │ -327 return false;
│ │ │ │ │ -328 c=file.peek();
│ │ │ │ │ -329 }
│ │ │ │ │ -330
│ │ │ │ │ -331 if(c=='\n') {
│ │ │ │ │ -332 /* eat the line feed */
│ │ │ │ │ -333 file.get();
│ │ │ │ │ -334 return true;
│ │ │ │ │ -335 }
│ │ │ │ │ -336 return false;
│ │ │ │ │ -337 }
│ │ │ │ │ -338
│ │ │ │ │ -_3_3_9 inline void _s_k_i_p_C_o_m_m_e_n_t_s(std::istream& file)
│ │ │ │ │ -340 {
│ │ │ │ │ -341 _l_i_n_e_F_e_e_d(file);
│ │ │ │ │ -342 char c=file.peek();
│ │ │ │ │ -343 // ignore comment lines
│ │ │ │ │ -344 while(c=='%')
│ │ │ │ │ -345 {
│ │ │ │ │ -346 /* discard the rest of the line */
│ │ │ │ │ -347 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -348 c=file.peek();
│ │ │ │ │ -349 }
│ │ │ │ │ -350 }
│ │ │ │ │ -351
│ │ │ │ │ -352
│ │ │ │ │ -_3_5_3 inline bool _r_e_a_d_M_a_t_r_i_x_M_a_r_k_e_t_B_a_n_n_e_r(std::istream& file, _M_M_H_e_a_d_e_r& mmHeader)
│ │ │ │ │ -354 {
│ │ │ │ │ -355 std::string buffer;
│ │ │ │ │ -356 char c;
│ │ │ │ │ -357 file >> buffer;
│ │ │ │ │ -358 c=buffer[0];
│ │ │ │ │ -359 mmHeader=_M_M_H_e_a_d_e_r();
│ │ │ │ │ -360 if(c!='%')
│ │ │ │ │ -361 return false;
│ │ │ │ │ -362 dverb<::max(),'\n');
│ │ │ │ │ -367 return false;
│ │ │ │ │ -368 }
│ │ │ │ │ -369
│ │ │ │ │ -370 if(_l_i_n_e_F_e_e_d(file))
│ │ │ │ │ -371 /* premature end of line */
│ │ │ │ │ -372 return false;
│ │ │ │ │ -373
│ │ │ │ │ -374 /* read the matrix_type */
│ │ │ │ │ -375 file >> buffer;
│ │ │ │ │ +_2_8_4 _S_e_q_S_O_R (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +285 : _A_(A), _n(n), _w(w)
│ │ │ │ │ +286 {
│ │ │ │ │ +287 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +288 }
│ │ │ │ │ +289
│ │ │ │ │ +_3_0_3 _S_e_q_S_O_R (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +304 : _S_e_q_S_O_R(A->getmat(), configuration)
│ │ │ │ │ +305 {}
│ │ │ │ │ +306
│ │ │ │ │ +_3_2_0 _S_e_q_S_O_R (const M& A, const ParameterTree& configuration)
│ │ │ │ │ +321 : _S_e_q_S_O_R(A, configuration._g_e_t("iterations",1),
│ │ │ │ │ +configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation",1.0))
│ │ │ │ │ +322 {}
│ │ │ │ │ +323
│ │ │ │ │ +_3_2_9 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +330 {}
│ │ │ │ │ +331
│ │ │ │ │ +_3_3_7 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +338 {
│ │ │ │ │ +339 this->template apply(v,d);
│ │ │ │ │ +340 }
│ │ │ │ │ +341
│ │ │ │ │ +350 template
│ │ │ │ │ +_3_5_1 void _a_p_p_l_y(X& v, const Y& d)
│ │ │ │ │ +352 {
│ │ │ │ │ +353 if(forward)
│ │ │ │ │ +354 for (int i=0; i<_n; i++) {
│ │ │ │ │ +355 _b_s_o_r_f(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +356 }
│ │ │ │ │ +357 else
│ │ │ │ │ +358 for (int i=0; i<_n; i++) {
│ │ │ │ │ +359 _b_s_o_r_b(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ +360 }
│ │ │ │ │ +361 }
│ │ │ │ │ +362
│ │ │ │ │ +_3_6_8 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +369 {}
│ │ │ │ │ +370
│ │ │ │ │ +_3_7_2 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
│ │ │ │ │ +373 {
│ │ │ │ │ +374 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +375 }
│ │ │ │ │ 376
│ │ │ │ │ -377 if(buffer != "matrix")
│ │ │ │ │ -378 {
│ │ │ │ │ -379 /* discard the rest of the line */
│ │ │ │ │ -380 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -381 return false;
│ │ │ │ │ -382 }
│ │ │ │ │ -383
│ │ │ │ │ -384 if(_l_i_n_e_F_e_e_d(file))
│ │ │ │ │ -385 /* premature end of line */
│ │ │ │ │ -386 return false;
│ │ │ │ │ +377 private:
│ │ │ │ │ +379 const M& _A_;
│ │ │ │ │ +381 int _n;
│ │ │ │ │ +383 _r_e_a_l___f_i_e_l_d___t_y_p_e _w;
│ │ │ │ │ +384 };
│ │ │ │ │ +_3_8_5 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("sor",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +386
│ │ │ │ │ 387
│ │ │ │ │ -388 /* The type of the matrix */
│ │ │ │ │ -389 file >> buffer;
│ │ │ │ │ -390
│ │ │ │ │ -391 if(buffer.empty())
│ │ │ │ │ -392 return false;
│ │ │ │ │ -393
│ │ │ │ │ -394 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
│ │ │ │ │ -395 ::tolower);
│ │ │ │ │ -396
│ │ │ │ │ -397 switch(buffer[0])
│ │ │ │ │ -398 {
│ │ │ │ │ -399 case 'a' :
│ │ │ │ │ -400 /* sanity check */
│ │ │ │ │ -401 if(buffer != "array")
│ │ │ │ │ -402 {
│ │ │ │ │ -403 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -404 return false;
│ │ │ │ │ -405 }
│ │ │ │ │ -406 mmHeader._t_y_p_e=_a_r_r_a_y___t_y_p_e;
│ │ │ │ │ -407 break;
│ │ │ │ │ -408 case 'c' :
│ │ │ │ │ -409 /* sanity check */
│ │ │ │ │ -410 if(buffer != "coordinate")
│ │ │ │ │ -411 {
│ │ │ │ │ -412 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -413 return false;
│ │ │ │ │ -414 }
│ │ │ │ │ -415 mmHeader._t_y_p_e=_c_o_o_r_d_i_n_a_t_e___t_y_p_e;
│ │ │ │ │ -416 break;
│ │ │ │ │ -417 default :
│ │ │ │ │ -418 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -419 return false;
│ │ │ │ │ -420 }
│ │ │ │ │ -421
│ │ │ │ │ -422 if(_l_i_n_e_F_e_e_d(file))
│ │ │ │ │ -423 /* premature end of line */
│ │ │ │ │ -424 return false;
│ │ │ │ │ -425
│ │ │ │ │ -426 /* The numeric type used. */
│ │ │ │ │ -427 file >> buffer;
│ │ │ │ │ -428
│ │ │ │ │ -429 if(buffer.empty())
│ │ │ │ │ -430 return false;
│ │ │ │ │ -431
│ │ │ │ │ -432 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
│ │ │ │ │ -433 ::tolower);
│ │ │ │ │ -434 switch(buffer[0])
│ │ │ │ │ -435 {
│ │ │ │ │ -436 case 'i' :
│ │ │ │ │ -437 /* sanity check */
│ │ │ │ │ -438 if(buffer != "integer")
│ │ │ │ │ -439 {
│ │ │ │ │ -440 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -441 return false;
│ │ │ │ │ -442 }
│ │ │ │ │ -443 mmHeader._c_t_y_p_e=_i_n_t_e_g_e_r___t_y_p_e;
│ │ │ │ │ -444 break;
│ │ │ │ │ -445 case 'r' :
│ │ │ │ │ -446 /* sanity check */
│ │ │ │ │ -447 if(buffer != "real")
│ │ │ │ │ -448 {
│ │ │ │ │ -449 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -450 return false;
│ │ │ │ │ -451 }
│ │ │ │ │ -452 mmHeader._c_t_y_p_e=_d_o_u_b_l_e___t_y_p_e;
│ │ │ │ │ -453 break;
│ │ │ │ │ -454 case 'c' :
│ │ │ │ │ -455 /* sanity check */
│ │ │ │ │ -456 if(buffer != "complex")
│ │ │ │ │ -457 {
│ │ │ │ │ -458 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -459 return false;
│ │ │ │ │ -460 }
│ │ │ │ │ -461 mmHeader._c_t_y_p_e=_c_o_m_p_l_e_x___t_y_p_e;
│ │ │ │ │ -462 break;
│ │ │ │ │ -463 case 'p' :
│ │ │ │ │ -464 /* sanity check */
│ │ │ │ │ -465 if(buffer != "pattern")
│ │ │ │ │ -466 {
│ │ │ │ │ -467 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -468 return false;
│ │ │ │ │ -469 }
│ │ │ │ │ -470 mmHeader._c_t_y_p_e=_p_a_t_t_e_r_n;
│ │ │ │ │ -471 break;
│ │ │ │ │ -472 default :
│ │ │ │ │ -473 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -474 return false;
│ │ │ │ │ -475 }
│ │ │ │ │ -476
│ │ │ │ │ -477 if(_l_i_n_e_F_e_e_d(file))
│ │ │ │ │ -478 return false;
│ │ │ │ │ -479
│ │ │ │ │ -480 file >> buffer;
│ │ │ │ │ -481
│ │ │ │ │ -482 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
│ │ │ │ │ -483 ::tolower);
│ │ │ │ │ -484 switch(buffer[0])
│ │ │ │ │ -485 {
│ │ │ │ │ -486 case 'g' :
│ │ │ │ │ -487 /* sanity check */
│ │ │ │ │ -488 if(buffer != "general")
│ │ │ │ │ +398 template
│ │ │ │ │ +_3_9_9 using _S_e_q_G_S = _S_e_q_S_O_R_<_M_,_X_,_Y_,_l_>;
│ │ │ │ │ +_4_0_0 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("gs",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +401
│ │ │ │ │ +412 template
│ │ │ │ │ +_4_1_3 class _S_e_q_J_a_c : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_X_,_Y_> {
│ │ │ │ │ +414 public:
│ │ │ │ │ +_4_1_6 typedef M _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_4_1_8 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_4_2_0 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_4_2_2 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_4_2_4 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_4_2_6 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +427
│ │ │ │ │ +_4_3_5 _S_e_q_J_a_c (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +436 : _A_(A), _n(n), _w(w)
│ │ │ │ │ +437 {
│ │ │ │ │ +438 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +439 }
│ │ │ │ │ +440
│ │ │ │ │ +_4_5_4 _S_e_q_J_a_c (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +455 : _S_e_q_J_a_c(A->getmat(), configuration)
│ │ │ │ │ +456 {}
│ │ │ │ │ +457
│ │ │ │ │ +_4_7_1 _S_e_q_J_a_c (const M& A, const ParameterTree& configuration)
│ │ │ │ │ +472 : _S_e_q_J_a_c(A, configuration._g_e_t("iterations",1),
│ │ │ │ │ +configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation",1.0))
│ │ │ │ │ +473 {}
│ │ │ │ │ +474
│ │ │ │ │ +_4_8_0 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +481 {}
│ │ │ │ │ +482
│ │ │ │ │ +_4_8_8 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ 489 {
│ │ │ │ │ -490 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -491 return false;
│ │ │ │ │ +490 for (int i=0; i<_n; i++) {
│ │ │ │ │ +491 _d_b_j_a_c(_A_,v,d,_w,_B_L_<_l_>());
│ │ │ │ │ 492 }
│ │ │ │ │ -493 mmHeader._s_t_r_u_c_t_u_r_e=_g_e_n_e_r_a_l;
│ │ │ │ │ -494 break;
│ │ │ │ │ -495 case 'h' :
│ │ │ │ │ -496 /* sanity check */
│ │ │ │ │ -497 if(buffer != "hermitian")
│ │ │ │ │ -498 {
│ │ │ │ │ -499 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -500 return false;
│ │ │ │ │ -501 }
│ │ │ │ │ -502 mmHeader._s_t_r_u_c_t_u_r_e=_h_e_r_m_i_t_i_a_n;
│ │ │ │ │ -503 break;
│ │ │ │ │ -504 case 's' :
│ │ │ │ │ -505 if(buffer.size()==1) {
│ │ │ │ │ -506 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -507 return false;
│ │ │ │ │ -508 }
│ │ │ │ │ -509
│ │ │ │ │ -510 switch(buffer[1])
│ │ │ │ │ -511 {
│ │ │ │ │ -512 case 'y' :
│ │ │ │ │ -513 /* sanity check */
│ │ │ │ │ -514 if(buffer != "symmetric")
│ │ │ │ │ -515 {
│ │ │ │ │ -516 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -517 return false;
│ │ │ │ │ -518 }
│ │ │ │ │ -519 mmHeader._s_t_r_u_c_t_u_r_e=_s_y_m_m_e_t_r_i_c;
│ │ │ │ │ -520 break;
│ │ │ │ │ -521 case 'k' :
│ │ │ │ │ -522 /* sanity check */
│ │ │ │ │ -523 if(buffer != "skew-symmetric")
│ │ │ │ │ -524 {
│ │ │ │ │ -525 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -526 return false;
│ │ │ │ │ -527 }
│ │ │ │ │ -528 mmHeader._s_t_r_u_c_t_u_r_e=_s_k_e_w___s_y_m_m_e_t_r_i_c;
│ │ │ │ │ -529 break;
│ │ │ │ │ -530 default :
│ │ │ │ │ -531 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -532 return false;
│ │ │ │ │ -533 }
│ │ │ │ │ -534 break;
│ │ │ │ │ -535 default :
│ │ │ │ │ -536 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -537 return false;
│ │ │ │ │ -538 }
│ │ │ │ │ -539 file.ignore(std::numeric_limits::max(),'\n');
│ │ │ │ │ -540 c=file.peek();
│ │ │ │ │ -541 return true;
│ │ │ │ │ -542
│ │ │ │ │ -543 }
│ │ │ │ │ -544
│ │ │ │ │ -545 template
│ │ │ │ │ -546 std::tuple
│ │ │ │ │ -_5_4_7 _c_a_l_c_u_l_a_t_e_N_N_Z(std::size_t rows, std::size_t cols, std::size_t entries, const
│ │ │ │ │ -_M_M_H_e_a_d_e_r& header)
│ │ │ │ │ -548 {
│ │ │ │ │ -549 std::size_t blockrows=rows/brows;
│ │ │ │ │ -550 std::size_t blockcols=cols/bcols;
│ │ │ │ │ -551 std::size_t blocksize=brows*bcols;
│ │ │ │ │ -552 std::size_t blockentries=0;
│ │ │ │ │ -553
│ │ │ │ │ -554 switch(header._s_t_r_u_c_t_u_r_e)
│ │ │ │ │ -555 {
│ │ │ │ │ -556 case _g_e_n_e_r_a_l :
│ │ │ │ │ -557 blockentries = entries/blocksize; break;
│ │ │ │ │ -558 case _s_k_e_w___s_y_m_m_e_t_r_i_c :
│ │ │ │ │ -559 blockentries = 2*entries/blocksize; break;
│ │ │ │ │ -560 case _s_y_m_m_e_t_r_i_c :
│ │ │ │ │ -561 blockentries = (2*entries-rows)/blocksize; break;
│ │ │ │ │ -562 case _h_e_r_m_i_t_i_a_n :
│ │ │ │ │ -563 blockentries = (2*entries-rows)/blocksize; break;
│ │ │ │ │ -564 default :
│ │ │ │ │ -565 throw Dune::NotImplemented();
│ │ │ │ │ -566 }
│ │ │ │ │ -567 return std::make_tuple(blockrows, blockcols, blockentries);
│ │ │ │ │ -568 }
│ │ │ │ │ -569
│ │ │ │ │ -570 /*
│ │ │ │ │ -571 * @brief Storage class for the column index and the numeric value.
│ │ │ │ │ -572 *
│ │ │ │ │ -573 * \tparam T Either a NumericWrapper of the numeric type or PatternDummy
│ │ │ │ │ -574 * for MatrixMarket pattern case.
│ │ │ │ │ -575 */
│ │ │ │ │ -576 template
│ │ │ │ │ -_5_7_7 struct _I_n_d_e_x_D_a_t_a : public T
│ │ │ │ │ -578 {
│ │ │ │ │ -_5_7_9 std::size_t _i_n_d_e_x = {};
│ │ │ │ │ -580 };
│ │ │ │ │ -581
│ │ │ │ │ +493 }
│ │ │ │ │ +494
│ │ │ │ │ +_5_0_0 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +501 {}
│ │ │ │ │ +502
│ │ │ │ │ +_5_0_4 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
│ │ │ │ │ +505 {
│ │ │ │ │ +506 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +507 }
│ │ │ │ │ +508
│ │ │ │ │ +509 private:
│ │ │ │ │ +511 const M& _A_;
│ │ │ │ │ +513 int _n;
│ │ │ │ │ +515 real_field_type _w;
│ │ │ │ │ +516 };
│ │ │ │ │ +_5_1_7 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("jac",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +518
│ │ │ │ │ +562 template
│ │ │ │ │ +_5_6_3 class _S_e_q_D_I_L_U : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r_<_X_,_ _Y_>
│ │ │ │ │ +564 {
│ │ │ │ │ +565 public:
│ │ │ │ │ +_5_6_7 using _m_a_t_r_i_x___t_y_p_e = M;
│ │ │ │ │ +_5_6_9 using _b_l_o_c_k___t_y_p_e = typename matrix_type::block_type;
│ │ │ │ │ +_5_7_1 using _d_o_m_a_i_n___t_y_p_e = X;
│ │ │ │ │ +_5_7_3 using _r_a_n_g_e___t_y_p_e = Y;
│ │ │ │ │ +574
│ │ │ │ │ +_5_7_6 using _f_i_e_l_d___t_y_p_e = typename X::field_type;
│ │ │ │ │ +577
│ │ │ │ │ +_5_7_9 using _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e = Simd::Scalar;
│ │ │ │ │ +_5_8_1 using _r_e_a_l___f_i_e_l_d___t_y_p_e = typename FieldTraits::real_type;
│ │ │ │ │ 582
│ │ │ │ │ -593 template
│ │ │ │ │ -_5_9_4 struct _N_u_m_e_r_i_c_W_r_a_p_p_e_r
│ │ │ │ │ -595 {
│ │ │ │ │ -_5_9_6 T _n_u_m_b_e_r = {};
│ │ │ │ │ -_5_9_7 operator T&()
│ │ │ │ │ -598 {
│ │ │ │ │ -599 return _n_u_m_b_e_r;
│ │ │ │ │ -600 }
│ │ │ │ │ -601 };
│ │ │ │ │ -602
│ │ │ │ │ -_6_0_6 struct _P_a_t_t_e_r_n_D_u_m_m_y
│ │ │ │ │ -607 {};
│ │ │ │ │ -608
│ │ │ │ │ -609 template<>
│ │ │ │ │ -_6_1_0 struct _N_u_m_e_r_i_c_W_r_a_p_p_e_r<_P_a_t_t_e_r_n_D_u_m_m_y>
│ │ │ │ │ -611 {};
│ │ │ │ │ -612
│ │ │ │ │ -613 template
│ │ │ │ │ -_6_1_4 std::istream& _o_p_e_r_a_t_o_r_>_>(std::istream& is, _N_u_m_e_r_i_c_W_r_a_p_p_e_r_<_T_>& num)
│ │ │ │ │ -615 {
│ │ │ │ │ -616 return is>>num._n_u_m_b_e_r;
│ │ │ │ │ -617 }
│ │ │ │ │ -618
│ │ │ │ │ -_6_1_9 inline std::istream& _o_p_e_r_a_t_o_r_>_>(std::istream& is, [[maybe_unused]]
│ │ │ │ │ -_N_u_m_e_r_i_c_W_r_a_p_p_e_r_<_P_a_t_t_e_r_n_D_u_m_m_y_>& num)
│ │ │ │ │ -620 {
│ │ │ │ │ -621 return is;
│ │ │ │ │ -622 }
│ │ │ │ │ -623
│ │ │ │ │ -629 template
│ │ │ │ │ -_6_3_0 bool _o_p_e_r_a_t_o_r_<(const _I_n_d_e_x_D_a_t_a_<_T_>& i1, const _I_n_d_e_x_D_a_t_a_<_T_>& i2)
│ │ │ │ │ +_5_8_9 _S_e_q_D_I_L_U(const M &A, _r_e_a_l___f_i_e_l_d___t_y_p_e w)
│ │ │ │ │ +590 : _A_(A),
│ │ │ │ │ +591 _w(w),
│ │ │ │ │ +592 wNotIdentity_([w]
│ │ │ │ │ +593 {using std::abs; return abs(w - _r_e_a_l___f_i_e_l_d___t_y_p_e(1)) > 1e-15; }())
│ │ │ │ │ +594 {
│ │ │ │ │ +595 Dinv_.resize(_A_.N());
│ │ │ │ │ +596 _C_h_e_c_k_I_f_D_i_a_g_o_n_a_l_P_r_e_s_e_n_t_<_M_,_ _l_>_:_:_c_h_e_c_k(_A_);
│ │ │ │ │ +597 _D_I_L_U_:_:_b_l_o_c_k_D_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n(_A_, Dinv_);
│ │ │ │ │ +598 }
│ │ │ │ │ +599
│ │ │ │ │ +_6_1_2 _S_e_q_D_I_L_U(const std::shared_ptr> &A,
│ │ │ │ │ +const ParameterTree &configuration)
│ │ │ │ │ +613 : _S_e_q_D_I_L_U(A->getmat(), configuration)
│ │ │ │ │ +614 {
│ │ │ │ │ +615 }
│ │ │ │ │ +616
│ │ │ │ │ +_6_2_9 _S_e_q_D_I_L_U(const M &A, const ParameterTree &config)
│ │ │ │ │ +630 : _S_e_q_D_I_L_U(A, config._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0))
│ │ │ │ │ 631 {
│ │ │ │ │ -632 return i1._i_n_d_e_x
│ │ │ │ │ -_6_4_1 std::istream& _o_p_e_r_a_t_o_r_>_>(std::istream& is, _I_n_d_e_x_D_a_t_a_<_T_>& data)
│ │ │ │ │ -642 {
│ │ │ │ │ -643 is>>data._i_n_d_e_x;
│ │ │ │ │ -644 /* MatrixMarket indices are one based. Decrement for C++ */
│ │ │ │ │ -645 --data._i_n_d_e_x;
│ │ │ │ │ -646 return is>>data.number;
│ │ │ │ │ -647 }
│ │ │ │ │ -648
│ │ │ │ │ -654 template
│ │ │ │ │ -_6_5_5 std::istream& _o_p_e_r_a_t_o_r_>_>(std::istream& is, _I_n_d_e_x_D_a_t_a<_N_u_m_e_r_i_c_W_r_a_p_p_e_r>>& data)
│ │ │ │ │ -656 {
│ │ │ │ │ -657 is>>data._i_n_d_e_x;
│ │ │ │ │ -658 /* MatrixMarket indices are one based. Decrement for C++ */
│ │ │ │ │ -659 --data.index;
│ │ │ │ │ -660 // real and imaginary part needs to be read separately as
│ │ │ │ │ -661 // complex numbers are not provided in pair form. (x,y)
│ │ │ │ │ -662 _N_u_m_e_r_i_c_W_r_a_p_p_e_r_<_T_> real, imag;
│ │ │ │ │ -663 is>>real;
│ │ │ │ │ -664 is>>imag;
│ │ │ │ │ -665 data._n_u_m_b_e_r = {real._n_u_m_b_e_r, imag._n_u_m_b_e_r};
│ │ │ │ │ -666 return is;
│ │ │ │ │ -667 }
│ │ │ │ │ -668
│ │ │ │ │ -675 template
│ │ │ │ │ -_6_7_6 struct _M_a_t_r_i_x_V_a_l_u_e_s_S_e_t_t_e_r
│ │ │ │ │ -677 {
│ │ │ │ │ -683 template
│ │ │ │ │ -_6_8_4 void _o_p_e_r_a_t_o_r_(_)(const std::vector > >& rows,
│ │ │ │ │ -685 _B_C_R_S_M_a_t_r_i_x_<_T_>& matrix)
│ │ │ │ │ -686 {
│ │ │ │ │ -687 static_assert(IsNumber::value && brows==1 && bcols==1, "Only scalar
│ │ │ │ │ -entries are expected here!");
│ │ │ │ │ -688 for (auto iter=matrix._b_e_g_i_n(); iter!= matrix._e_n_d(); ++iter)
│ │ │ │ │ -689 {
│ │ │ │ │ -690 auto brow=iter.index();
│ │ │ │ │ -691 for (auto siter=rows[brow].begin(); siter != rows[brow].end(); ++siter)
│ │ │ │ │ -692 (*iter)[siter->index] = siter->number;
│ │ │ │ │ -693 }
│ │ │ │ │ -694 }
│ │ │ │ │ -695
│ │ │ │ │ -701 template
│ │ │ │ │ -_7_0_2 void _o_p_e_r_a_t_o_r_(_)(const std::vector > >& rows,
│ │ │ │ │ -703 _B_C_R_S_M_a_t_r_i_x<_F_i_e_l_d_M_a_t_r_i_x_<_T_,_b_r_o_w_s_,_b_c_o_l_s_> >& matrix)
│ │ │ │ │ -704 {
│ │ │ │ │ -705 for (auto iter=matrix.begin(); iter!= matrix.end(); ++iter)
│ │ │ │ │ -706 {
│ │ │ │ │ -707 for (auto brow=iter.index()*brows,
│ │ │ │ │ -708 browend=iter.index()*brows+brows;
│ │ │ │ │ -709 browindex/bcols][brow%brows][siter->index%bcols]=siter->number;
│ │ │ │ │ -714 }
│ │ │ │ │ -715 }
│ │ │ │ │ -716 }
│ │ │ │ │ -717 };
│ │ │ │ │ +632 }
│ │ │ │ │ +633
│ │ │ │ │ +_6_3_9 virtual void _p_r_e([[maybe_unused]] X &x, [[maybe_unused]] Y &b)
│ │ │ │ │ +640 {
│ │ │ │ │ +641 }
│ │ │ │ │ +642
│ │ │ │ │ +_6_4_8 virtual void _a_p_p_l_y(X &v, const Y &d)
│ │ │ │ │ +649 {
│ │ │ │ │ +650
│ │ │ │ │ +651 _D_I_L_U_:_:_b_l_o_c_k_D_I_L_U_B_a_c_k_s_o_l_v_e(_A_, Dinv_, v, d);
│ │ │ │ │ +652
│ │ │ │ │ +653 if (wNotIdentity_)
│ │ │ │ │ +654 {
│ │ │ │ │ +655 v *= _w;
│ │ │ │ │ +656 }
│ │ │ │ │ +657 }
│ │ │ │ │ +658
│ │ │ │ │ +_6_6_4 virtual void _p_o_s_t([[maybe_unused]] X &x)
│ │ │ │ │ +665 {
│ │ │ │ │ +666 }
│ │ │ │ │ +667
│ │ │ │ │ +_6_6_9 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
│ │ │ │ │ +670 {
│ │ │ │ │ +671 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ +672 }
│ │ │ │ │ +673
│ │ │ │ │ +674 protected:
│ │ │ │ │ +_6_7_5 std::vector _D_i_n_v__;
│ │ │ │ │ +_6_7_7 const M &___A__;
│ │ │ │ │ +_6_7_9 const _r_e_a_l___f_i_e_l_d___t_y_p_e ___w;
│ │ │ │ │ +_6_8_1 const bool _w_N_o_t_I_d_e_n_t_i_t_y__;
│ │ │ │ │ +682 };
│ │ │ │ │ +_6_8_3 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("dilu",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +684
│ │ │ │ │ +696 template
│ │ │ │ │ +_6_9_7 class _S_e_q_I_L_U : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +698 public:
│ │ │ │ │ +_7_0_0 typedef typename std::remove_const::type _m_a_t_r_i_x___t_y_p_e;
│ │ │ │ │ +_7_0_2 typedef typename matrix_type :: block_type _b_l_o_c_k___t_y_p_e;
│ │ │ │ │ +_7_0_4 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_7_0_6 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +707
│ │ │ │ │ +_7_0_9 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +710
│ │ │ │ │ +_7_1_2 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_7_1_4 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +715
│ │ │ │ │ +_7_1_7 typedef typename _I_L_U_:_:_C_R_S_<_ _b_l_o_c_k___t_y_p_e_ _,_ _t_y_p_e_n_a_m_e_ _M_:_:_a_l_l_o_c_a_t_o_r___t_y_p_e_> _C_R_S;
│ │ │ │ │ 718
│ │ │ │ │ -719 template
│ │ │ │ │ -_7_2_0 struct _M_a_t_r_i_x_V_a_l_u_e_s_S_e_t_t_e_r<_P_a_t_t_e_r_n_D_u_m_m_y,brows,bcols>
│ │ │ │ │ -721 {
│ │ │ │ │ -722 template
│ │ │ │ │ -_7_2_3 void _o_p_e_r_a_t_o_r_(_)(const std::vector > >&
│ │ │ │ │ -rows,
│ │ │ │ │ -724 M& matrix)
│ │ │ │ │ -725 {}
│ │ │ │ │ -726 };
│ │ │ │ │ -727
│ │ │ │ │ -_7_2_8 template struct _i_s___c_o_m_p_l_e_x : std::false_type {};
│ │ │ │ │ -_7_2_9 template struct _i_s___c_o_m_p_l_e_x<_s_t_d::complex> : std::true_type {};
│ │ │ │ │ +_7_2_6 _S_e_q_I_L_U (const M& A, _r_e_a_l___f_i_e_l_d___t_y_p_e w, const bool resort = false )
│ │ │ │ │ +727 : _S_e_q_I_L_U( A, 0, w, resort ) // construct ILU(0)
│ │ │ │ │ +728 {
│ │ │ │ │ +729 }
│ │ │ │ │ 730
│ │ │ │ │ -731 // wrapper for std::conj. Returns T if T is not complex.
│ │ │ │ │ -732 template
│ │ │ │ │ -_7_3_3 std::enable_if_t::value, T> _c_o_n_j(const T& r){
│ │ │ │ │ -734 return r;
│ │ │ │ │ -735 }
│ │ │ │ │ -736
│ │ │ │ │ -737 template
│ │ │ │ │ -_7_3_8 std::enable_if_t::value, T> _c_o_n_j(const T& r){
│ │ │ │ │ -739 return std::conj(r);
│ │ │ │ │ -740 }
│ │ │ │ │ -741
│ │ │ │ │ -742 template
│ │ │ │ │ -_7_4_3 struct _m_m___m_u_l_t_i_p_l_i_e_r_s
│ │ │ │ │ -744 {};
│ │ │ │ │ -745
│ │ │ │ │ -746 template
│ │ │ │ │ -_7_4_7 struct _m_m___m_u_l_t_i_p_l_i_e_r_s<_B_C_R_S_M_a_t_r_i_x >
│ │ │ │ │ -748 {
│ │ │ │ │ -749 enum {
│ │ │ │ │ -_7_5_0 rows = 1,
│ │ │ │ │ -751 cols = 1
│ │ │ │ │ -_7_5_2 };
│ │ │ │ │ -753 };
│ │ │ │ │ -754
│ │ │ │ │ -755 template
│ │ │ │ │ -_7_5_6 struct _m_m___m_u_l_t_i_p_l_i_e_r_s<_B_C_R_S_M_a_t_r_i_x<_F_i_e_l_d_M_a_t_r_i_x,A> >
│ │ │ │ │ -757 {
│ │ │ │ │ -758 enum {
│ │ │ │ │ -_7_5_9 rows = i,
│ │ │ │ │ -760 cols = j
│ │ │ │ │ -_7_6_1 };
│ │ │ │ │ -762 };
│ │ │ │ │ -763
│ │ │ │ │ -764 template
│ │ │ │ │ -_7_6_5 void _r_e_a_d_S_p_a_r_s_e_E_n_t_r_i_e_s(_D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_<_T_,_A_>& matrix,
│ │ │ │ │ -766 std::istream& file, std::size_t entries,
│ │ │ │ │ -767 const _M_M_H_e_a_d_e_r& mmHeader, const D&)
│ │ │ │ │ -768 {
│ │ │ │ │ -769 typedef _D_u_n_e_:_:_B_C_R_S_M_a_t_r_i_x_<_T_,_A_> _M_a_t_r_i_x;
│ │ │ │ │ -770
│ │ │ │ │ -771 // Number of rows and columns of T, if it is a matrix (1x1 otherwise)
│ │ │ │ │ -772 constexpr int brows = _m_m___m_u_l_t_i_p_l_i_e_r_s_<_M_a_t_r_i_x_>_:_:_r_o_w_s;
│ │ │ │ │ -773 constexpr int bcols = _m_m___m_u_l_t_i_p_l_i_e_r_s_<_M_a_t_r_i_x_>_:_:_c_o_l_s;
│ │ │ │ │ -774
│ │ │ │ │ -775 // First path
│ │ │ │ │ -776 // store entries together with column index in a separate
│ │ │ │ │ -777 // data structure
│ │ │ │ │ -778 std::vector > > rows(matrix._N()*brows);
│ │ │ │ │ -779
│ │ │ │ │ -780 auto readloop = [&] (auto symmetryFixup) {
│ │ │ │ │ -781 for(std::size_t i = 0; i < entries; ++i) {
│ │ │ │ │ -782 std::size_t row;
│ │ │ │ │ -783 _I_n_d_e_x_D_a_t_a_<_D_> data;
│ │ │ │ │ -784 _s_k_i_p_C_o_m_m_e_n_t_s(file);
│ │ │ │ │ -785 file>>row;
│ │ │ │ │ -786 --row; // Index was 1 based.
│ │ │ │ │ -787 assert(row/bcols>data;
│ │ │ │ │ -789 assert(data._i_n_d_e_x/bcols data_sym(data);
│ │ │ │ │ -804 data_sym._i_n_d_e_x = row;
│ │ │ │ │ -805 rows[data.index].insert(data_sym);
│ │ │ │ │ -806 });
│ │ │ │ │ -807 break;
│ │ │ │ │ -808 case _s_k_e_w___s_y_m_m_e_t_r_i_c :
│ │ │ │ │ -809 readloop([&](auto row, auto data) {
│ │ │ │ │ -810 _I_n_d_e_x_D_a_t_a_<_D_> data_sym;
│ │ │ │ │ -811 data_sym.number = -data.number;
│ │ │ │ │ -812 data_sym._i_n_d_e_x = row;
│ │ │ │ │ -813 rows[data.index].insert(data_sym);
│ │ │ │ │ -814 });
│ │ │ │ │ -815 break;
│ │ │ │ │ -816 case _h_e_r_m_i_t_i_a_n :
│ │ │ │ │ -817 readloop([&](auto row, auto data) {
│ │ │ │ │ -818 _I_n_d_e_x_D_a_t_a_<_D_> data_sym;
│ │ │ │ │ -819 data_sym.number = _c_o_n_j(data.number);
│ │ │ │ │ -820 data_sym._i_n_d_e_x = row;
│ │ │ │ │ -821 rows[data.index].insert(data_sym);
│ │ │ │ │ -822 });
│ │ │ │ │ -823 break;
│ │ │ │ │ -824 default:
│ │ │ │ │ -825 DUNE_THROW(Dune::NotImplemented,
│ │ │ │ │ -826 "Only general, symmetric, skew-symmetric and hermitian is supported right
│ │ │ │ │ -now!");
│ │ │ │ │ -827 }
│ │ │ │ │ -828
│ │ │ │ │ -829 // Setup the matrix sparsity pattern
│ │ │ │ │ -830 int nnz=0;
│ │ │ │ │ -831 for(typename Matrix::CreateIterator iter=matrix._c_r_e_a_t_e_b_e_g_i_n();
│ │ │ │ │ -832 iter!= matrix._c_r_e_a_t_e_e_n_d(); ++iter)
│ │ │ │ │ +_7_4_5 _S_e_q_I_L_U (const std::shared_ptr>& A,
│ │ │ │ │ +const ParameterTree& configuration)
│ │ │ │ │ +746 : _S_e_q_I_L_U(A->getmat(), configuration)
│ │ │ │ │ +747 {}
│ │ │ │ │ +748
│ │ │ │ │ +_7_6_3 _S_e_q_I_L_U(const M& A, const ParameterTree& config)
│ │ │ │ │ +764 : _S_e_q_I_L_U(A, config._g_e_t("n", 0),
│ │ │ │ │ +765 config._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0),
│ │ │ │ │ +766 config._g_e_t("resort", false))
│ │ │ │ │ +767 {}
│ │ │ │ │ +768
│ │ │ │ │ +_7_7_7 _S_e_q_I_L_U (const M& A, int n, _r_e_a_l___f_i_e_l_d___t_y_p_e w, const bool resort = false )
│ │ │ │ │ +778 : _I_L_U__(),
│ │ │ │ │ +779 _l_o_w_e_r__(),
│ │ │ │ │ +780 _u_p_p_e_r__(),
│ │ │ │ │ +781 _i_n_v__(),
│ │ │ │ │ +782 _w__(w),
│ │ │ │ │ +783 _w_N_o_t_I_d_e_n_t_i_t_y__([w]{using std::abs; return abs(w - _r_e_a_l___f_i_e_l_d___t_y_p_e(1)) > 1e-
│ │ │ │ │ +15;}() )
│ │ │ │ │ +784 {
│ │ │ │ │ +785 if( n == 0 )
│ │ │ │ │ +786 {
│ │ │ │ │ +787 // copy A
│ │ │ │ │ +788 _I_L_U__.reset( new _m_a_t_r_i_x___t_y_p_e( A ) );
│ │ │ │ │ +789 // create ILU(0) decomposition
│ │ │ │ │ +790 _I_L_U_:_:_b_l_o_c_k_I_L_U_0_D_e_c_o_m_p_o_s_i_t_i_o_n( *_I_L_U__ );
│ │ │ │ │ +791 }
│ │ │ │ │ +792 else
│ │ │ │ │ +793 {
│ │ │ │ │ +794 // create matrix in build mode
│ │ │ │ │ +795 _I_L_U__.reset( new _m_a_t_r_i_x___t_y_p_e( A.N(), A.M(), matrix_type::row_wise) );
│ │ │ │ │ +796 // create ILU(n) decomposition
│ │ │ │ │ +797 _I_L_U_:_:_b_l_o_c_k_I_L_U_D_e_c_o_m_p_o_s_i_t_i_o_n( A, n, *_I_L_U__ );
│ │ │ │ │ +798 }
│ │ │ │ │ +799
│ │ │ │ │ +800 if( resort )
│ │ │ │ │ +801 {
│ │ │ │ │ +802 // store ILU in simple CRS format
│ │ │ │ │ +803 _I_L_U_:_:_c_o_n_v_e_r_t_T_o_C_R_S( *_I_L_U__, _l_o_w_e_r__, _u_p_p_e_r__, _i_n_v__ );
│ │ │ │ │ +804 _I_L_U__.reset();
│ │ │ │ │ +805 }
│ │ │ │ │ +806 }
│ │ │ │ │ +807
│ │ │ │ │ +_8_1_3 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +814 {}
│ │ │ │ │ +815
│ │ │ │ │ +_8_2_1 virtual void _a_p_p_l_y (X& v, const Y& d)
│ │ │ │ │ +822 {
│ │ │ │ │ +823 if( _I_L_U__ )
│ │ │ │ │ +824 {
│ │ │ │ │ +825 _I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e( *_I_L_U__, v, d);
│ │ │ │ │ +826 }
│ │ │ │ │ +827 else
│ │ │ │ │ +828 {
│ │ │ │ │ +829 _I_L_U_:_:_b_l_o_c_k_I_L_U_B_a_c_k_s_o_l_v_e(_l_o_w_e_r__, _u_p_p_e_r__, _i_n_v__, v, d);
│ │ │ │ │ +830 }
│ │ │ │ │ +831
│ │ │ │ │ +832 if( _w_N_o_t_I_d_e_n_t_i_t_y__ )
│ │ │ │ │ 833 {
│ │ │ │ │ -834 for(std::size_t brow=iter.index()*brows, browend=iter.index()*brows+brows;
│ │ │ │ │ -835 brow >::const_iterator Siter;
│ │ │ │ │ -838 for(Siter siter=rows[brow].begin(), send=rows[brow].end();
│ │ │ │ │ -839 siter != send; ++siter, ++nnz)
│ │ │ │ │ -840 iter.insert(siter->index/bcols);
│ │ │ │ │ -841 }
│ │ │ │ │ -842 }
│ │ │ │ │ -843
│ │ │ │ │ -844 //Set the matrix values
│ │ │ │ │ -845 matrix=0;
│ │ │ │ │ -846
│ │ │ │ │ -847 _M_a_t_r_i_x_V_a_l_u_e_s_S_e_t_t_e_r_<_D_,_b_r_o_w_s_,_b_c_o_l_s_> Setter;
│ │ │ │ │ -848
│ │ │ │ │ -849 Setter(rows, matrix);
│ │ │ │ │ +834 v *= _w__;
│ │ │ │ │ +835 }
│ │ │ │ │ +836 }
│ │ │ │ │ +837
│ │ │ │ │ +_8_4_3 virtual void _p_o_s_t ([[maybe_unused]] X& x)
│ │ │ │ │ +844 {}
│ │ │ │ │ +845
│ │ │ │ │ +_8_4_7 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
│ │ │ │ │ +848 {
│ │ │ │ │ +849 return _S_o_l_v_e_r_C_a_t_e_g_o_r_y_:_:_s_e_q_u_e_n_t_i_a_l;
│ │ │ │ │ 850 }
│ │ │ │ │ 851
│ │ │ │ │ -_8_5_2 inline std::tuple _s_p_l_i_t_F_i_l_e_n_a_m_e(const std::
│ │ │ │ │ -string& filename) {
│ │ │ │ │ -853 std::size_t lastdot = filename.find_last_of(".");
│ │ │ │ │ -854 if(lastdot == std::string::npos)
│ │ │ │ │ -855 return std::make_tuple(filename, "");
│ │ │ │ │ -856 else {
│ │ │ │ │ -857 std::string potentialFileExtension = filename.substr(lastdot);
│ │ │ │ │ -858 if (potentialFileExtension == ".mm" || potentialFileExtension == ".mtx")
│ │ │ │ │ -859 return std::make_tuple(filename.substr(0, lastdot),
│ │ │ │ │ -potentialFileExtension);
│ │ │ │ │ -860 else
│ │ │ │ │ -861 return std::make_tuple(filename, "");
│ │ │ │ │ -862 }
│ │ │ │ │ -863 }
│ │ │ │ │ -864
│ │ │ │ │ -865 } // end namespace MatrixMarketImpl
│ │ │ │ │ -866
│ │ │ │ │ -_8_6_7 class _M_a_t_r_i_x_M_a_r_k_e_t_F_o_r_m_a_t_E_r_r_o_r : public Dune::Exception
│ │ │ │ │ -868 {};
│ │ │ │ │ -869
│ │ │ │ │ -870
│ │ │ │ │ -_8_7_1 inline void _m_m___r_e_a_d___h_e_a_d_e_r(std::size_t& rows, std::size_t& cols,
│ │ │ │ │ -872 _M_a_t_r_i_x_M_a_r_k_e_t_I_m_p_l_:_:_M_M_H_e_a_d_e_r& header, std::istream& istr,
│ │ │ │ │ -873 bool isVector)
│ │ │ │ │ -874 {
│ │ │ │ │ -875 using namespace MatrixMarketImpl;
│ │ │ │ │ -876
│ │ │ │ │ -877 if(!readMatrixMarketBanner(istr, header)) {
│ │ │ │ │ -878 std::cerr << "First line was not a correct Matrix Market banner. Using
│ │ │ │ │ -default:\n"
│ │ │ │ │ -879 << "%%MatrixMarket matrix coordinate real general"<> rows;
│ │ │ │ │ -893
│ │ │ │ │ -894 if(lineFeed(istr))
│ │ │ │ │ -895 throw _M_a_t_r_i_x_M_a_r_k_e_t_F_o_r_m_a_t_E_r_r_o_r();
│ │ │ │ │ -896 istr >> cols;
│ │ │ │ │ -897 }
│ │ │ │ │ -898
│ │ │ │ │ -899 template
│ │ │ │ │ -_9_0_0 void _m_m___r_e_a_d___v_e_c_t_o_r___e_n_t_r_i_e_s(_D_u_n_e_:_:_B_l_o_c_k_V_e_c_t_o_r_<_T_,_A_>& vector,
│ │ │ │ │ -901 std::size_t size,
│ │ │ │ │ -902 std::istream& istr,
│ │ │ │ │ -903 size_t lane)
│ │ │ │ │ -904 {
│ │ │ │ │ -905 for (int i=0; size>0; ++i, --size)
│ │ │ │ │ -906 istr>>Simd::lane(lane,vector[i]);
│ │ │ │ │ -907 }
│ │ │ │ │ -908
│ │ │ │ │ -909 template
│ │ │ │ │ -_9_1_0 void _m_m___r_e_a_d___v_e_c_t_o_r___e_n_t_r_i_e_s(_D_u_n_e_:_:_B_l_o_c_k_V_e_c_t_o_r,A>& vector,
│ │ │ │ │ -911 std::size_t size,
│ │ │ │ │ -912 std::istream& istr,
│ │ │ │ │ -913 size_t lane)
│ │ │ │ │ -914 {
│ │ │ │ │ -915 for(int i=0; size>0; ++i, --size) {
│ │ │ │ │ -916 Simd::Scalar val;
│ │ │ │ │ -917 istr>>val;
│ │ │ │ │ -918 Simd::lane(lane, vector[i/entries][i%entries])=val;
│ │ │ │ │ -919 }
│ │ │ │ │ -920 }
│ │ │ │ │ -921
│ │ │ │ │ +852 protected:
│ │ │ │ │ +_8_5_4 std::unique_ptr< matrix_type > _I_L_U__;
│ │ │ │ │ +855
│ │ │ │ │ +_8_5_7 _C_R_S _l_o_w_e_r__;
│ │ │ │ │ +_8_5_8 _C_R_S _u_p_p_e_r__;
│ │ │ │ │ +_8_5_9 std::vector< block_type, typename matrix_type::allocator_type > _i_n_v__;
│ │ │ │ │ +860
│ │ │ │ │ +_8_6_2 const _r_e_a_l___f_i_e_l_d___t_y_p_e _w__;
│ │ │ │ │ +_8_6_4 const bool _w_N_o_t_I_d_e_n_t_i_t_y__;
│ │ │ │ │ +865 };
│ │ │ │ │ +_8_6_6 _D_U_N_E___R_E_G_I_S_T_E_R___P_R_E_C_O_N_D_I_T_I_O_N_E_R("ilu",
│ │ │ │ │ +defaultPreconditionerBlockLevelCreator());
│ │ │ │ │ +867
│ │ │ │ │ +868
│ │ │ │ │ +877 template
│ │ │ │ │ +_8_7_8 class _R_i_c_h_a_r_d_s_o_n : public _P_r_e_c_o_n_d_i_t_i_o_n_e_r {
│ │ │ │ │ +879 public:
│ │ │ │ │ +_8_8_1 typedef X _d_o_m_a_i_n___t_y_p_e;
│ │ │ │ │ +_8_8_3 typedef Y _r_a_n_g_e___t_y_p_e;
│ │ │ │ │ +_8_8_5 typedef typename X::field_type _f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_8_7 typedef Simd::Scalar _s_c_a_l_a_r___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +_8_8_9 typedef typename FieldTraits::real_type _r_e_a_l___f_i_e_l_d___t_y_p_e;
│ │ │ │ │ +890
│ │ │ │ │ +_8_9_6 _R_i_c_h_a_r_d_s_o_n (_r_e_a_l___f_i_e_l_d___t_y_p_e w=1.0) :
│ │ │ │ │ +897 _w(w)
│ │ │ │ │ +898 {}
│ │ │ │ │ +899
│ │ │ │ │ +_9_1_1 _R_i_c_h_a_r_d_s_o_n (const ParameterTree& configuration)
│ │ │ │ │ +912 : _R_i_c_h_a_r_d_s_o_n(configuration._g_e_t<_r_e_a_l___f_i_e_l_d___t_y_p_e>("relaxation", 1.0))
│ │ │ │ │ +913 {}
│ │ │ │ │ +914
│ │ │ │ │ +_9_2_0 virtual void _p_r_e ([[maybe_unused]] X& x, [[maybe_unused]] Y& b)
│ │ │ │ │ +921 {}
│ │ │ │ │ 922
│ │ │ │ │ -929 template
│ │ │ │ │ -_9_3_0 void _r_e_a_d_M_a_t_r_i_x_M_a_r_k_e_t(_D_u_n_e_:_:_B_l_o_c_k_V_e_c_t_o_r_<_T_,_A_>& vector,
│ │ │ │ │ -931 std::istream& istr)
│ │ │ │ │ -932 {
│ │ │ │ │ -933 typedef typename _D_u_n_e_:_:_B_l_o_c_k_V_e_c_t_o_r_<_T_,_A_>_:_:_f_i_e_l_d___t_y_p_e field_type;
│ │ │ │ │ -934 using namespace MatrixMarketImpl;
│ │ │ │ │ -935
│ │ │ │ │ -936 MMHeader header;
│ │ │ │ │ -937 std::size_t rows, cols;
│ │ │ │ │ -938 _m_m___r_e_a_d___h_e_a_d_e_r(rows,cols,header,istr, true);
│ │ │ │ │ -939 if(cols!=Simd::lanes()) {
│ │ │ │ │ -940 if(Simd::lanes
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,20 +1,41 @@
│ │ │ │ │ dune-istl 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _i_s_t_l
│ │ │ │ │ -_M_a_c_r_o_s
│ │ │ │ │ -superlufunctions.hh File Reference
│ │ │ │ │ -#include