17 #ifndef __deal2__block_matrix_base_h 18 #define __deal2__block_matrix_base_h 21 #include <deal.II/base/config.h> 22 #include <deal.II/base/table.h> 23 #include <deal.II/base/thread_management.h> 24 #include <deal.II/base/utilities.h> 25 #include <deal.II/base/smartpointer.h> 26 #include <deal.II/base/memory_consumption.h> 27 #include <deal.II/lac/block_indices.h> 28 #include <deal.II/lac/exceptions.h> 29 #include <deal.II/lac/full_matrix.h> 30 #include <deal.II/lac/matrix_iterator.h> 31 #include <deal.II/lac/vector.h> 58 template <
class BlockMatrix>
120 template <
class BlockMatrix,
bool ConstNess>
128 template <
class BlockMatrix>
165 const size_type col);
172 size_type row()
const;
179 size_type column()
const;
185 value_type value()
const;
190 void set_value(value_type newval)
const;
213 bool operator == (
const Accessor &a)
const;
216 friend class Accessor<BlockMatrix, true>;
224 template <
class BlockMatrix>
261 const size_type col);
274 size_type row()
const;
281 size_type column()
const;
287 value_type value()
const;
309 bool operator == (
const Accessor &a)
const;
316 friend class ::MatrixIterator;
381 template <
typename MatrixType>
396 typedef value_type *pointer;
397 typedef const value_type *const_pointer;
398 typedef value_type &reference;
399 typedef const value_type &const_reference;
448 template <
class BlockMatrixType>
450 copy_from (
const BlockMatrixType &source);
457 block (
const unsigned int row,
458 const unsigned int column);
467 block (
const unsigned int row,
468 const unsigned int column)
const;
476 size_type m ()
const;
484 size_type n ()
const;
493 unsigned int n_block_rows ()
const;
501 unsigned int n_block_cols ()
const;
512 void set (
const size_type i,
514 const value_type value);
543 template <
typename number>
544 void set (
const std::vector<size_type> &indices,
546 const bool elide_zero_values =
false);
555 template <
typename number>
556 void set (
const std::vector<size_type> &row_indices,
557 const std::vector<size_type> &col_indices,
559 const bool elide_zero_values =
false);
579 template <
typename number>
580 void set (
const size_type row,
581 const std::vector<size_type> &col_indices,
582 const std::vector<number> &values,
583 const bool elide_zero_values =
false);
601 template <
typename number>
602 void set (
const size_type row,
603 const size_type n_cols,
604 const size_type *col_indices,
605 const number *values,
606 const bool elide_zero_values =
false);
617 void add (
const size_type i,
619 const value_type value);
648 template <
typename number>
649 void add (
const std::vector<size_type> &indices,
651 const bool elide_zero_values =
true);
660 template <
typename number>
661 void add (
const std::vector<size_type> &row_indices,
662 const std::vector<size_type> &col_indices,
664 const bool elide_zero_values =
true);
683 template <
typename number>
684 void add (
const size_type row,
685 const std::vector<size_type> &col_indices,
686 const std::vector<number> &values,
687 const bool elide_zero_values =
true);
706 template <
typename number>
707 void add (
const size_type row,
708 const size_type n_cols,
709 const size_type *col_indices,
710 const number *values,
711 const bool elide_zero_values =
true,
712 const bool col_indices_are_sorted =
false);
726 void add (
const value_type factor,
740 value_type operator () (
const size_type i,
741 const size_type j)
const;
760 value_type el (
const size_type i,
761 const size_type j)
const;
780 value_type diag_element (
const size_type i)
const;
791 void compress (::VectorOperation::values operation);
816 template <class BlockVectorType>
817 void vmult_add (BlockVectorType &dst,
818 const BlockVectorType &src) const;
830 template <class BlockVectorType>
831 void Tvmult_add (BlockVectorType &dst,
832 const BlockVectorType &src) const;
858 template <class BlockVectorType>
860 matrix_norm_square (const BlockVectorType &v) const;
866 template <class BlockVectorType>
868 matrix_scalar_product (const BlockVectorType &u,
869 const BlockVectorType &v) const;
876 template <class BlockVectorType>
877 value_type residual (BlockVectorType &dst,
878 const BlockVectorType &x,
879 const BlockVectorType &b) const;
891 void print (
std::ostream &out,
892 const
bool alternative_output = false) const;
909 iterator begin (const size_type r);
914 iterator end (const size_type r);
919 const_iterator begin () const;
924 const_iterator end () const;
930 const_iterator begin (const size_type r) const;
935 const_iterator end (const size_type r) const;
957 std::
size_t memory_consumption () const;
967 << "The blocks [" << arg1 << ',' << arg2 << "] and ["
968 << arg3 << ',' << arg4 << "] have differing row
numbers.");
974 << "The blocks [" << arg1 << ',' << arg2 << "] and ["
975 << arg3 << ',' << arg4 << "] have differing column numbers.");
1045 void collect_sizes ();
1063 template <class BlockVectorType>
1064 void vmult_block_block (BlockVectorType &dst,
1065 const BlockVectorType &src) const;
1085 template <class BlockVectorType,
1087 void vmult_block_nonblock (BlockVectorType &dst,
1088 const VectorType &src) const;
1108 template <class BlockVectorType,
1110 void vmult_nonblock_block (VectorType &dst,
1111 const BlockVectorType &src) const;
1131 template <class VectorType>
1132 void vmult_nonblock_nonblock (VectorType &dst,
1133 const VectorType &src) const;
1154 template <class BlockVectorType>
1155 void Tvmult_block_block (BlockVectorType &dst,
1156 const BlockVectorType &src) const;
1176 template <class BlockVectorType,
1178 void Tvmult_block_nonblock (BlockVectorType &dst,
1179 const VectorType &src) const;
1199 template <class BlockVectorType,
1201 void Tvmult_nonblock_block (VectorType &dst,
1202 const BlockVectorType &src) const;
1222 template <class VectorType>
1223 void Tvmult_nonblock_nonblock (VectorType &dst,
1224 const VectorType &src) const;
1239 void prepare_add_operation();
1246 void prepare_set_operation();
1304 TemporaryData &operator = (
const TemporaryData &)
1324 template <
typename,
bool>
1340 template <
class BlockMatrix>
1349 template <
class BlockMatrix>
1352 AccessorBase<BlockMatrix>::block_row()
const 1361 template <
class BlockMatrix>
1364 AccessorBase<BlockMatrix>::block_column()
const 1373 template <
class BlockMatrix>
1375 Accessor<BlockMatrix, true>::Accessor (
1376 const BlockMatrix *matrix,
1377 const size_type row,
1378 const size_type col)
1387 if (row < matrix->
m())
1389 const std::pair<unsigned int,size_type> indices
1390 = matrix->row_block_indices.global_to_local(row);
1394 for (
unsigned int bc=0; bc<matrix->n_block_cols(); ++bc)
1397 = matrix->block(indices.first, bc).begin(indices.second);
1398 if (base_iterator !=
1399 matrix->block(indices.first, bc).end(indices.second))
1401 this->row_block = indices.first;
1402 this->col_block = bc;
1413 *
this = Accessor (matrix, row+1, 0);
1437 template <
class BlockMatrix>
1439 Accessor<BlockMatrix, true>::Accessor (
const Accessor<BlockMatrix, false> &other)
1441 matrix(other.matrix),
1442 base_iterator(other.base_iterator)
1444 this->row_block = other.row_block;
1445 this->col_block = other.col_block;
1449 template <
class BlockMatrix>
1451 typename Accessor<BlockMatrix, true>::size_type
1452 Accessor<BlockMatrix, true>::row()
const 1457 return (matrix->row_block_indices.local_to_global(this->row_block, 0) +
1458 base_iterator->row());
1462 template <
class BlockMatrix>
1464 typename Accessor<BlockMatrix, true>::size_type
1465 Accessor<BlockMatrix, true>::column()
const 1470 return (matrix->column_block_indices.local_to_global(this->col_block,0) +
1471 base_iterator->column());
1475 template <
class BlockMatrix>
1477 typename Accessor<BlockMatrix, true>::value_type
1478 Accessor<BlockMatrix, true>::value ()
const 1485 return base_iterator->value();
1490 template <
class BlockMatrix>
1493 Accessor<BlockMatrix, true>::advance ()
1501 size_type local_row = base_iterator->row();
1512 while (base_iterator ==
1513 matrix->block(this->row_block, this->col_block).end(local_row))
1522 = matrix->block(this->row_block, this->col_block).begin(local_row);
1528 this->col_block = 0;
1537 if (local_row == matrix->block(this->row_block, this->col_block).m())
1541 if (this->row_block == matrix->n_block_rows())
1550 = matrix->block(this->row_block, this->col_block).begin(local_row);
1556 template <
class BlockMatrix>
1559 Accessor<BlockMatrix, true>::operator == (
const Accessor &a)
const 1561 if (matrix != a.matrix)
1564 if (this->row_block == a.row_block
1565 && this->col_block == a.col_block)
1574 (base_iterator == a.base_iterator));
1582 template <
class BlockMatrix>
1584 Accessor<BlockMatrix, false>::Accessor (
1585 BlockMatrix *matrix,
1586 const size_type row,
1587 const size_type col)
1595 if (row < matrix->
m())
1597 const std::pair<unsigned int,size_type> indices
1598 = matrix->row_block_indices.global_to_local(row);
1602 for (size_type bc=0; bc<matrix->n_block_cols(); ++bc)
1605 = matrix->block(indices.first, bc).begin(indices.second);
1606 if (base_iterator !=
1607 matrix->block(indices.first, bc).end(indices.second))
1609 this->row_block = indices.first;
1610 this->col_block = bc;
1621 *
this = Accessor (matrix, row+1, 0);
1633 template <
class BlockMatrix>
1635 typename Accessor<BlockMatrix, false>::size_type
1636 Accessor<BlockMatrix, false>::row()
const 1641 return (matrix->row_block_indices.local_to_global(this->row_block, 0) +
1642 base_iterator->row());
1646 template <
class BlockMatrix>
1648 typename Accessor<BlockMatrix, false>::size_type
1649 Accessor<BlockMatrix, false>::column()
const 1654 return (matrix->column_block_indices.local_to_global(this->col_block,0) +
1655 base_iterator->column());
1659 template <
class BlockMatrix>
1661 typename Accessor<BlockMatrix, false>::value_type
1662 Accessor<BlockMatrix, false>::value ()
const 1669 return base_iterator->value();
1674 template <
class BlockMatrix>
1677 Accessor<BlockMatrix, false>::set_value (
typename Accessor<BlockMatrix, false>::value_type newval)
const 1684 base_iterator->value() = newval;
1689 template <
class BlockMatrix>
1692 Accessor<BlockMatrix, false>::advance ()
1700 size_type local_row = base_iterator->row();
1711 while (base_iterator ==
1712 matrix->block(this->row_block, this->col_block).end(local_row))
1721 = matrix->block(this->row_block, this->col_block).begin(local_row);
1727 this->col_block = 0;
1736 if (local_row == matrix->block(this->row_block, this->col_block).m())
1740 if (this->row_block == matrix->n_block_rows())
1749 = matrix->block(this->row_block, this->col_block).begin(local_row);
1756 template <
class BlockMatrix>
1759 Accessor<BlockMatrix, false>::operator == (
const Accessor &a)
const 1761 if (matrix != a.matrix)
1764 if (this->row_block == a.row_block
1765 && this->col_block == a.col_block)
1774 (base_iterator == a.base_iterator));
1784 template <
typename MatrixType>
1789 template <
typename MatrixType>
1797 template <
class MatrixType>
1798 template <
class BlockMatrixType>
1802 copy_from (
const BlockMatrixType &source)
1806 block(r,c).copy_from (source.block(r,c));
1812 template <
class MatrixType>
1837 template <
class MatrixType>
1857 template <
class MatrixType>
1861 const unsigned int column)
1873 template <
class MatrixType>
1877 const unsigned int column)
const 1888 template <
class MatrixType>
1890 typename BlockMatrixBase<MatrixType>::size_type
1898 template <
class MatrixType>
1900 typename BlockMatrixBase<MatrixType>::size_type
1908 template <
class MatrixType>
1913 return column_block_indices.
size();
1918 template <
class MatrixType>
1931 template <
class MatrixType>
1942 const std::pair<unsigned int,size_type>
1945 block(row_index.first,col_index.first).set (row_index.second,
1952 template <
class MatrixType>
1953 template <
typename number>
1957 const std::vector<size_type> &col_indices,
1959 const bool elide_zero_values)
1961 Assert (row_indices.size() == values.
m(),
1963 Assert (col_indices.size() == values.
n(),
1966 for (size_type i=0; i<row_indices.size(); ++i)
1967 set (row_indices[i], col_indices.size(), &col_indices[0], &values(i,0),
1973 template <
class MatrixType>
1974 template <
typename number>
1979 const bool elide_zero_values)
1981 Assert (indices.size() == values.
m(),
1983 Assert (values.
n() == values.
m(), ExcNotQuadratic());
1985 for (size_type i=0; i<indices.size(); ++i)
1986 set (indices[i], indices.size(), &indices[0], &values(i,0),
1992 template <
class MatrixType>
1993 template <
typename number>
1997 const std::vector<size_type> &col_indices,
1998 const std::vector<number> &values,
1999 const bool elide_zero_values)
2001 Assert (col_indices.size() == values.size(),
2004 set (row, col_indices.size(), &col_indices[0], &values[0],
2013 template <
class MatrixType>
2014 template <
typename number>
2018 const size_type n_cols,
2019 const size_type *col_indices,
2020 const number *values,
2021 const bool elide_zero_values)
2070 for (size_type j=0; j<n_cols; ++j)
2072 double value = values[j];
2074 if (value == 0 && elide_zero_values ==
true)
2077 const std::pair<unsigned int, size_type>
2078 col_index = this->column_block_indices.
global_to_local(col_indices[j]);
2089 size_type length = 0;
2100 const std::pair<unsigned int,size_type>
2102 for (
unsigned int block_col=0; block_col<
n_block_cols(); ++block_col)
2107 block(row_index.first, block_col).set
2118 template <
class MatrixType>
2133 typedef typename MatrixType::Traits MatrixTraits;
2134 if ((MatrixTraits::zero_addition_can_be_elided ==
true)
2139 const std::pair<unsigned int,size_type>
2142 block(row_index.first,col_index.first).add (row_index.second,
2149 template <
class MatrixType>
2150 template <
typename number>
2154 const std::vector<size_type> &col_indices,
2156 const bool elide_zero_values)
2158 Assert (row_indices.size() == values.
m(),
2160 Assert (col_indices.size() == values.
n(),
2163 for (size_type i=0; i<row_indices.size(); ++i)
2164 add (row_indices[i], col_indices.size(), &col_indices[0], &values(i,0),
2170 template <
class MatrixType>
2171 template <
typename number>
2176 const bool elide_zero_values)
2178 Assert (indices.size() == values.
m(),
2180 Assert (values.
n() == values.
m(), ExcNotQuadratic());
2182 for (size_type i=0; i<indices.size(); ++i)
2183 add (indices[i], indices.size(), &indices[0], &values(i,0),
2189 template <
class MatrixType>
2190 template <
typename number>
2194 const std::vector<size_type> &col_indices,
2195 const std::vector<number> &values,
2196 const bool elide_zero_values)
2198 Assert (col_indices.size() == values.size(),
2201 add (row, col_indices.size(), &col_indices[0], &values[0],
2210 template <
class MatrixType>
2211 template <
typename number>
2215 const size_type n_cols,
2216 const size_type *col_indices,
2217 const number *values,
2218 const bool elide_zero_values,
2219 const bool col_indices_are_sorted)
2226 if (col_indices_are_sorted ==
true)
2231 size_type before = col_indices[0];
2232 for (size_type i=1; i<n_cols; ++i)
2233 if (col_indices[i] <= before)
2235 "indices appear to not be sorted."))
2237 before = col_indices[i];
2239 const std::pair<unsigned int,size_type>
2248 const size_type n_zero_block_indices = first_block - col_indices;
2249 block(row_index.first, 0).add (row_index.second,
2250 n_zero_block_indices,
2254 col_indices_are_sorted);
2256 if (n_zero_block_indices < n_cols)
2257 this->
add(row, n_cols - n_zero_block_indices, first_block,
2258 values + n_zero_block_indices, elide_zero_values,
2263 block(row_index.first, 0).
add (row_index.second,
2268 col_indices_are_sorted);
2317 for (size_type j=0; j<n_cols; ++j)
2319 double value = values[j];
2321 if (value == 0 && elide_zero_values ==
true)
2324 const std::pair<unsigned int, size_type>
2325 col_index = this->column_block_indices.
global_to_local(col_indices[j]);
2336 size_type length = 0;
2347 const std::pair<unsigned int,size_type>
2349 for (
unsigned int block_col=0; block_col<
n_block_cols(); ++block_col)
2354 block(row_index.first, block_col).add
2360 col_indices_are_sorted);
2366 template <
class MatrixType>
2379 typedef typename MatrixType::Traits MatrixTraits;
2380 if ((MatrixTraits::zero_addition_can_be_elided ==
true)
2389 block(row, col).add(factor, matrix.
block(row,col));
2394 template <
class MatrixType>
2398 const size_type j)
const 2400 const std::pair<unsigned int,size_type>
2403 return block(row_index.first,col_index.first) (row_index.second,
2409 template <
class MatrixType>
2413 const size_type j)
const 2415 const std::pair<unsigned int,size_type>
2418 return block(row_index.first,col_index.first).el (row_index.second,
2424 template <
class MatrixType>
2432 const std::pair<unsigned int,size_type>
2434 return block(index.first,index.first).diag_element(index.second);
2439 template <
class MatrixType>
2446 block(r,c).compress (operation);
2449 template <
class MatrixType>
2454 compress(::VectorOperation::unknown);
2459 template <
class MatrixType>
2469 block(r,c) *= factor;
2476 template <
class MatrixType>
2489 block(r,c) *= factor_inv;
2496 template <
class MatrixType>
2505 template <
class MatrixType>
2509 return this->column_block_indices;
2514 template <
class MatrixType>
2515 template <
class BlockVectorType>
2519 const BlockVectorType &src)
const 2528 block(row,0).vmult (dst.block(row),
2531 block(row,col).vmult_add (dst.block(row),
2538 template <
class MatrixType>
2539 template <
class BlockVectorType,
2544 const BlockVectorType &src)
const 2551 block(0,0).vmult (dst, src.block(0));
2553 block(0,col).vmult_add (dst, src.block(col));
2558 template <
class MatrixType>
2559 template <
class BlockVectorType,
2564 const VectorType &src)
const 2572 block(row,0).vmult (dst.block(row),
2578 template <
class MatrixType>
2579 template <
class VectorType>
2583 const VectorType &src)
const 2590 block(0,0).vmult (dst, src);
2595 template <
class MatrixType>
2596 template <
class BlockVectorType>
2599 const BlockVectorType &src)
const 2608 block(row,col).vmult_add (dst.block(row),
2615 template <
class MatrixType>
2616 template <
class BlockVectorType>
2620 const BlockVectorType &src)
const 2632 block(row,col).Tvmult_add (dst.block(col),
2639 template <
class MatrixType>
2640 template <
class BlockVectorType,
2645 const VectorType &src)
const 2655 block(0,col).Tvmult_add (dst.block(col), src);
2660 template <
class MatrixType>
2661 template <
class BlockVectorType,
2666 const BlockVectorType &src)
const 2673 block(0,0).Tvmult (dst, src.block(0));
2676 block(row,0).Tvmult_add (dst, src.block(row));
2681 template <
class MatrixType>
2682 template <
class VectorType>
2686 const VectorType &src)
const 2693 block(0,0).Tvmult (dst, src);
2698 template <
class MatrixType>
2699 template <
class BlockVectorType>
2702 const BlockVectorType &src)
const 2711 block(row,col).Tvmult_add (dst.block(col),
2717 template <
class MatrixType>
2718 template <
class BlockVectorType>
2730 norm_sqr +=
block(row,col).matrix_norm_square (v.block(row));
2732 norm_sqr +=
block(row,col).matrix_scalar_product (v.block(row),
2739 template <
class MatrixType>
2740 template <
class BlockVectorType>
2744 const BlockVectorType &v)
const 2754 result +=
block(row,col).matrix_scalar_product (u.block(row),
2761 template <
class MatrixType>
2762 template <
class BlockVectorType>
2766 const BlockVectorType &x,
2767 const BlockVectorType &b)
const 2791 block(row,0).residual (dst.block(row),
2795 for (size_type i=0; i<dst.block(row).size(); ++i)
2796 dst.block(row)(i) = -dst.block(row)(i);
2799 block(row,col).vmult_add (dst.block(row),
2802 for (size_type i=0; i<dst.block(row).size(); ++i)
2803 dst.block(row)(i) = -dst.block(row)(i);
2808 res += dst.block(row).norm_sqr ();
2809 return std::sqrt(res);
2814 template <
class MatrixType>
2818 const bool alternative_output)
const 2823 if (!alternative_output)
2824 out <<
"Block (" << row <<
", " << col <<
")" << std::endl;
2826 block(row, col).print(out, alternative_output);
2832 template <
class MatrixType>
2842 template <
class MatrixType>
2852 template <
class MatrixType>
2863 template <
class MatrixType>
2874 template <
class MatrixType>
2884 template <
class MatrixType>
2894 template <
class MatrixType>
2905 template <
class MatrixType>
2916 template <
class MatrixType>
2920 std::vector<size_type> row_sizes (this->
n_block_rows());
2921 std::vector<size_type> col_sizes (this->
n_block_cols());
2933 ExcIncompatibleRowNumbers (r,0,r,c));
2946 ExcIncompatibleRowNumbers (0,c,r,c));
2950 this->column_block_indices.
reinit (col_sizes);
2955 template <
class MatrixType>
2961 block(row, col).prepare_add();
2966 template <
class MatrixType>
2972 block(row, col).prepare_set();
2978 DEAL_II_NAMESPACE_CLOSE
2980 #endif // __deal2__block_matrix_base_h Iterator lower_bound(Iterator first, Iterator last, const T &val)
const types::global_dof_index invalid_size_type
value_type matrix_scalar_product(const BlockVectorType &u, const BlockVectorType &v) const
static const unsigned int invalid_unsigned_int
const BlockMatrix * matrix
const BlockMatrix MatrixType
void reinit(const TableIndices< N > &new_size, const bool fast=false)
BlockMatrixBase & copy_from(const BlockMatrixType &source)
void Tvmult_nonblock_nonblock(VectorType &dst, const VectorType &src) const
void vmult_block_block(BlockVectorType &dst, const BlockVectorType &src) const
std::vector< size_type > counter_within_block
BlockMatrix::BlockType::const_iterator base_iterator
void vmult_nonblock_nonblock(VectorType &dst, const VectorType &src) const
std::vector< std::vector< size_type > > column_indices
void set(const size_type i, const size_type j, const value_type value)
types::global_dof_index size_type
void print(std::ostream &out, const bool alternative_output=false) const
::ExceptionBase & ExcMessage(std::string arg1)
value_type residual(BlockVectorType &dst, const BlockVectorType &x, const BlockVectorType &b) const
Auxiliary class aiding in the handling of block structures like in BlockVector or FESystem...
unsigned int block_row() const
void Tvmult_block_nonblock(BlockVectorType &dst, const VectorType &src) const
void add(const size_type i, const size_type j, const value_type value)
unsigned int n_block_cols() const
void vmult_block_nonblock(BlockVectorType &dst, const VectorType &src) const
TemporaryData temporary_data
value_type el(const size_type i, const size_type j) const
BlockMatrixBase & operator*=(const value_type factor)
bool is_finite(const double x)
BlockMatrix::BlockType::iterator base_iterator
BlockMatrixBase & operator/=(const value_type factor)
size_type block_start(const unsigned int i) const
void vmult_nonblock_block(VectorType &dst, const BlockVectorType &src) const
const BlockIndices & get_row_indices() const
unsigned int global_dof_index
BlockMatrix::value_type value_type
void compress() DEAL_II_DEPRECATED
#define Assert(cond, exc)
void Tvmult_add(BlockVectorType &dst, const BlockVectorType &src) const
std::size_t memory_consumption(const T &t)
types::global_dof_index size_type
void reinit(const unsigned int n_blocks, const size_type n_elements_per_block)
size_type total_size() const
const BlockIndices & get_column_indices() const
void prepare_add_operation()
BlockMatrix::value_type value_type
::ExceptionBase & ExcIndexRange(int arg1, int arg2, int arg3)
BlockType::value_type value_type
BlockCompressedSparsityPattern CompressedBlockSparsityPattern DEAL_II_DEPRECATED
value_type operator()(const size_type i, const size_type j) const
value_type diag_element(const size_type i) const
std::pair< unsigned int, size_type > global_to_local(const size_type i) const
value_type matrix_norm_square(const BlockVectorType &v) const
unsigned int block_column() const
void vmult_add(BlockVectorType &dst, const BlockVectorType &src) const
::ExceptionBase & ExcIteratorPastEnd()
std::size_t memory_consumption() const
::ExceptionBase & ExcNumberNotFinite()
BlockMatrix::value_type value_type
void Tvmult_nonblock_block(VectorType &dst, const BlockVectorType &src) const
void Tvmult_block_block(BlockVectorType &dst, const BlockVectorType &src) const
BlockType & block(const unsigned int row, const unsigned int column)
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Table< 2, SmartPointer< BlockType, BlockMatrixBase< MatrixType > > > sub_objects
std::vector< std::vector< double > > column_values
::ExceptionBase & ExcNotImplemented()
::ExceptionBase & ExcNotInitialized()
BlockIndices row_block_indices
unsigned int size() const
::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
types::global_dof_index size_type
::ExceptionBase & ExcInternalError()
::ExceptionBase & ExcDivideByZero()
void prepare_set_operation()
unsigned int n_block_rows() const