16 #ifndef dealii_sparse_matrix_h
17 #define dealii_sparse_matrix_h
38 template <
typename number>
40 template <
typename number>
42 template <
typename Matrix>
44 template <
typename number>
46 # ifdef DEAL_II_WITH_MPI
51 template <
typename Number>
58 # ifdef DEAL_II_WITH_TRILINOS
83 template <
typename number,
bool Constness>
96 template <
typename number,
bool Constness>
128 template <
typename number>
178 template <
typename,
bool>
189 template <
typename number>
229 operator number()
const;
311 template <
typename,
bool>
346 template <
typename number,
bool Constness>
471 template <
typename number,
bool Constness>
477 typename ::SparseMatrixIterators::Iterator<number,
480 Iterator<number, Constness>::difference_type;
519 template <
typename number>
702 template <
typename number2>
816 template <
typename number2>
818 set(
const std::vector<size_type> &indices,
820 const bool elide_zero_values =
false);
827 template <
typename number2>
829 set(
const std::vector<size_type> &row_indices,
830 const std::vector<size_type> &col_indices,
832 const bool elide_zero_values =
false);
844 template <
typename number2>
847 const std::vector<size_type> &col_indices,
848 const std::vector<number2> &
values,
849 const bool elide_zero_values =
false);
860 template <
typename number2>
866 const bool elide_zero_values =
false);
890 template <
typename number2>
892 add(
const std::vector<size_type> &indices,
894 const bool elide_zero_values =
true);
901 template <
typename number2>
903 add(
const std::vector<size_type> &row_indices,
904 const std::vector<size_type> &col_indices,
906 const bool elide_zero_values =
true);
917 template <
typename number2>
920 const std::vector<size_type> &col_indices,
921 const std::vector<number2> &
values,
922 const bool elide_zero_values =
true);
933 template <
typename number2>
939 const bool elide_zero_values =
true,
940 const bool col_indices_are_sorted =
false);
985 template <
typename somenumber>
1005 template <
typename ForwardIterator>
1018 template <
typename somenumber>
1022 #ifdef DEAL_II_WITH_TRILINOS
1047 template <
typename somenumber>
1134 template <
class OutVector,
class InVector>
1136 vmult(OutVector &dst,
const InVector &src)
const;
1153 template <
class OutVector,
class InVector>
1155 Tvmult(OutVector &dst,
const InVector &src)
const;
1173 template <
class OutVector,
class InVector>
1192 template <
class OutVector,
class InVector>
1213 template <
typename somenumber>
1222 template <
typename somenumber>
1236 template <
typename somenumber>
1277 template <
typename numberB,
typename numberC>
1282 const bool rebuild_sparsity_pattern =
true)
const;
1308 template <
typename numberB,
typename numberC>
1313 const bool rebuild_sparsity_pattern =
true)
const;
1358 template <
typename somenumber>
1362 const number omega = 1.)
const;
1370 template <
typename somenumber>
1374 const number omega = 1.,
1375 const std::vector<std::size_t> &pos_right_of_diagonal =
1376 std::vector<std::size_t>())
const;
1381 template <
typename somenumber>
1385 const number omega = 1.)
const;
1390 template <
typename somenumber>
1394 const number omega = 1.)
const;
1401 template <
typename somenumber>
1409 template <
typename somenumber>
1417 template <
typename somenumber>
1431 template <
typename somenumber>
1434 const std::vector<size_type> &permutation,
1435 const std::vector<size_type> &inverse_permutation,
1436 const number omega = 1.)
const;
1448 template <
typename somenumber>
1451 const std::vector<size_type> &permutation,
1452 const std::vector<size_type> &inverse_permutation,
1453 const number omega = 1.)
const;
1460 template <
typename somenumber>
1464 const number omega = 1.)
const;
1470 template <
typename somenumber>
1474 const number omega = 1.)
const;
1480 template <
typename somenumber>
1484 const number omega = 1.)
const;
1490 template <
typename somenumber>
1494 const number omega = 1.)
const;
1580 template <
typename StreamType>
1583 const bool across =
false,
1584 const bool diagonal_first =
true)
const;
1610 const unsigned int precision = 3,
1611 const bool scientific =
true,
1612 const unsigned int width = 0,
1613 const char *zero_string =
" ",
1614 const double denominator = 1.,
1615 const char *separator =
" ")
const;
1635 const unsigned int precision = 9)
const;
1680 <<
"You are trying to access the matrix entry with index <"
1681 << arg1 <<
',' << arg2
1682 <<
">, but this entry does not exist in the sparsity pattern "
1685 "The most common cause for this problem is that you used "
1686 "a method to build the sparsity pattern that did not "
1687 "(completely) take into account all of the entries you "
1688 "will later try to write into. An example would be "
1689 "building a sparsity pattern that does not include "
1690 "the entries you will write into due to constraints "
1691 "on degrees of freedom such as hanging nodes or periodic "
1692 "boundary conditions. In such cases, building the "
1693 "sparsity pattern will succeed, but you will get errors "
1694 "such as the current one at one point or other when "
1695 "trying to write into the entries of the matrix.");
1700 "When copying one sparse matrix into another, "
1701 "or when adding one sparse matrix to another, "
1702 "both matrices need to refer to the same "
1703 "sparsity pattern.");
1710 <<
"The iterators denote a range of " << arg1
1711 <<
" elements, but the given number of rows was " << arg2);
1716 "You are attempting an operation on two vectors that "
1717 "are the same object, but the operation requires that the "
1718 "two objects are in fact different.");
1757 std::unique_ptr<number[]>
val;
1768 template <
typename somenumber>
1770 template <
typename somenumber>
1780 template <
typename,
bool>
1782 template <
typename,
bool>
1785 #ifdef DEAL_II_WITH_MPI
1787 template <
typename Number>
1800 template <
typename number>
1801 template <
typename number2>
1810 template <
typename number>
1819 template <
typename number>
1829 template <
typename number>
1844 ExcInvalidIndex(i, j));
1853 template <
typename number>
1854 template <
typename number2>
1858 const bool elide_zero_values)
1864 for (
size_type i = 0; i < indices.size(); ++i)
1874 template <
typename number>
1875 template <
typename number2>
1878 const std::vector<size_type> &col_indices,
1880 const bool elide_zero_values)
1887 for (
size_type i = 0; i < row_indices.size(); ++i)
1897 template <
typename number>
1898 template <
typename number2>
1901 const std::vector<size_type> &col_indices,
1902 const std::vector<number2> &
values,
1903 const bool elide_zero_values)
1917 template <
typename number>
1925 if (
value == number())
1935 ExcInvalidIndex(i, j));
1944 template <
typename number>
1945 template <
typename number2>
1949 const bool elide_zero_values)
1955 for (
size_type i = 0; i < indices.size(); ++i)
1965 template <
typename number>
1966 template <
typename number2>
1969 const std::vector<size_type> &col_indices,
1971 const bool elide_zero_values)
1978 for (
size_type i = 0; i < row_indices.size(); ++i)
1988 template <
typename number>
1989 template <
typename number2>
1992 const std::vector<size_type> &col_indices,
1993 const std::vector<number2> &
values,
1994 const bool elide_zero_values)
2004 std::is_sorted(col_indices.begin(), col_indices.end()));
2009 template <
typename number>
2016 number *val_ptr = val.get();
2017 const number *
const end_ptr = val.get() + cols->n_nonzero_elements();
2019 while (val_ptr != end_ptr)
2020 *val_ptr++ *= factor;
2027 template <
typename number>
2035 const number factor_inv = number(1.) / factor;
2037 number *val_ptr = val.get();
2038 const number *
const end_ptr = val.get() + cols->n_nonzero_elements();
2040 while (val_ptr != end_ptr)
2041 *val_ptr++ *= factor_inv;
2048 template <
typename number>
2049 inline const number &
2054 ExcInvalidIndex(i, j));
2055 return val[cols->operator()(i, j)];
2060 template <
typename number>
2066 ExcInvalidIndex(i, j));
2067 return val[cols->operator()(i, j)];
2072 template <
typename number>
2087 template <
typename number>
2097 return val[cols->rowstart[i]];
2102 template <
typename number>
2112 return val[cols->rowstart[i]];
2117 template <
typename number>
2118 template <
typename ForwardIterator>
2121 const ForwardIterator
end)
2124 ExcIteratorRange(std::distance(
begin,
end), m()));
2128 using inner_iterator =
2129 typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
2131 for (ForwardIterator i =
begin; i !=
end; ++i, ++
row)
2133 const inner_iterator end_of_row = i->end();
2134 for (inner_iterator j = i->begin(); j != end_of_row; ++j)
2136 set(
row, j->first, j->second);
2146 template <
typename number>
2148 const std::size_t index_within_matrix)
2150 index_within_matrix)
2156 template <
typename number>
2157 inline Accessor<number, true>::Accessor(
const MatrixType *
matrix)
2164 template <
typename number>
2165 inline Accessor<number, true>::Accessor(
2168 ,
matrix(&a.get_matrix())
2173 template <
typename number>
2175 Accessor<number, true>::value()
const
2178 return matrix->val[linear_index];
2183 template <
typename number>
2184 inline const typename Accessor<number, true>::MatrixType &
2185 Accessor<number, true>::get_matrix()
const
2192 template <
typename number>
2193 inline Accessor<number, false>::Reference::Reference(
const Accessor *accessor,
2195 : accessor(accessor)
2199 template <
typename number>
2200 inline Accessor<number, false>::Reference::operator number()
const
2203 accessor->matrix->n_nonzero_elements());
2204 return accessor->matrix->val[accessor->linear_index];
2209 template <
typename number>
2210 inline const typename Accessor<number, false>::Reference &
2211 Accessor<number, false>::Reference::operator=(
const number n)
const
2214 accessor->matrix->n_nonzero_elements());
2215 accessor->matrix->val[accessor->linear_index] = n;
2221 template <
typename number>
2222 inline const typename Accessor<number, false>::Reference &
2223 Accessor<number, false>::Reference::operator+=(
const number n)
const
2226 accessor->matrix->n_nonzero_elements());
2227 accessor->matrix->val[accessor->linear_index] += n;
2233 template <
typename number>
2234 inline const typename Accessor<number, false>::Reference &
2235 Accessor<number, false>::Reference::operator-=(
const number n)
const
2238 accessor->matrix->n_nonzero_elements());
2239 accessor->matrix->val[accessor->linear_index] -= n;
2245 template <
typename number>
2246 inline const typename Accessor<number, false>::Reference &
2247 Accessor<number, false>::Reference::operator*=(
const number n)
const
2250 accessor->matrix->n_nonzero_elements());
2251 accessor->matrix->val[accessor->linear_index] *= n;
2257 template <
typename number>
2258 inline const typename Accessor<number, false>::Reference &
2259 Accessor<number, false>::Reference::operator/=(
const number n)
const
2262 accessor->matrix->n_nonzero_elements());
2263 accessor->matrix->val[accessor->linear_index] /= n;
2269 template <
typename number>
2270 inline Accessor<number, false>::Accessor(MatrixType *
matrix,
2271 const std::size_t index)
2278 template <
typename number>
2279 inline Accessor<number, false>::Accessor(MatrixType *
matrix)
2286 template <
typename number>
2287 inline typename Accessor<number, false>::Reference
2288 Accessor<number, false>::value()
const
2290 return Reference(
this,
true);
2295 template <
typename number>
2296 inline typename Accessor<number, false>::MatrixType &
2297 Accessor<number, false>::get_matrix()
const
2304 template <
typename number,
bool Constness>
2305 inline Iterator<number, Constness>::Iterator(MatrixType *
matrix,
2306 const std::size_t index)
2312 template <
typename number,
bool Constness>
2313 inline Iterator<number, Constness>::Iterator(MatrixType *
matrix)
2319 template <
typename number,
bool Constness>
2320 inline Iterator<number, Constness>::Iterator(
2327 template <
typename number,
bool Constness>
2328 inline const Iterator<number, Constness> &
2329 Iterator<number, Constness>::operator=(
2338 template <
typename number,
bool Constness>
2339 inline Iterator<number, Constness> &
2347 template <
typename number,
bool Constness>
2348 inline Iterator<number, Constness>
2351 const Iterator iter = *
this;
2357 template <
typename number,
bool Constness>
2358 inline const Accessor<number, Constness> &
2365 template <
typename number,
bool Constness>
2366 inline const Accessor<number, Constness> *
2367 Iterator<number, Constness>::operator->()
const
2373 template <
typename number,
bool Constness>
2377 return (accessor == other.accessor);
2381 template <
typename number,
bool Constness>
2385 return !(*
this == other);
2389 template <
typename number,
bool Constness>
2393 Assert(&accessor.get_matrix() == &other.accessor.get_matrix(),
2396 return (accessor < other.accessor);
2400 template <
typename number,
bool Constness>
2404 return (other < *
this);
2408 template <
typename number,
bool Constness>
2412 Assert(&accessor.get_matrix() == &other.accessor.get_matrix(),
2415 return (*this)->linear_index - other->linear_index;
2420 template <
typename number,
bool Constness>
2421 inline Iterator<number, Constness>
2435 template <
typename number>
2439 return const_iterator(
this, 0);
2443 template <
typename number>
2447 return const_iterator(
this);
2451 template <
typename number>
2455 return iterator(
this, 0);
2459 template <
typename number>
2463 return iterator(
this, cols->rowstart[cols->rows]);
2467 template <
typename number>
2473 return const_iterator(
this, cols->rowstart[r]);
2478 template <
typename number>
2484 return const_iterator(
this, cols->rowstart[r + 1]);
2489 template <
typename number>
2495 return iterator(
this, cols->rowstart[r]);
2500 template <
typename number>
2506 return iterator(
this, cols->rowstart[r + 1]);
2511 template <
typename number>
2512 template <
typename StreamType>
2516 const bool diagonal_first)
const
2521 bool hanging_diagonal =
false;
2524 for (
size_type i = 0; i < cols->rows; ++i)
2526 for (
size_type j = cols->rowstart[i]; j < cols->rowstart[i + 1]; ++j)
2528 if (!diagonal_first && i == cols->colnums[j])
2531 hanging_diagonal =
true;
2535 if (hanging_diagonal && cols->colnums[j] > i)
2538 out <<
' ' << i <<
',' << i <<
':' <<
diagonal;
2540 out <<
'(' << i <<
',' << i <<
") " <<
diagonal
2542 hanging_diagonal =
false;
2545 out <<
' ' << i <<
',' << cols->colnums[j] <<
':' << val[j];
2547 out <<
'(' << i <<
',' << cols->colnums[j] <<
") " << val[j]
2551 if (hanging_diagonal)
2554 out <<
' ' << i <<
',' << i <<
':' <<
diagonal;
2556 out <<
'(' << i <<
',' << i <<
") " <<
diagonal << std::endl;
2557 hanging_diagonal =
false;
2565 template <
typename number>
2574 template <
typename number>
bool operator!=(const AlignedVector< T > &lhs, const AlignedVector< T > &rhs)
bool operator==(const AlignedVector< T > &lhs, const AlignedVector< T > &rhs)
const Reference & operator+=(const number n) const
Reference(const Accessor *accessor, const bool dummy)
const Reference & operator=(const number n) const
const Reference & operator/=(const number n) const
const Reference & operator*=(const number n) const
const Accessor * accessor
const Reference & operator-=(const number n) const
Accessor(MatrixType *matrix, const std::size_t index)
MatrixType & get_matrix() const
Accessor(MatrixType *matrix)
Accessor(MatrixType *matrix)
Accessor(const SparseMatrixIterators::Accessor< number, false > &a)
const MatrixType & get_matrix() const
Accessor(MatrixType *matrix, const std::size_t index_within_matrix)
const SparseMatrix< number > & get_matrix() const
bool operator>(const Iterator &) const
bool operator==(const Iterator &) const
int operator-(const Iterator &p) const
bool operator<(const Iterator &) const
Iterator(MatrixType *matrix)
const Accessor< number, Constness > & value_type
Iterator operator+(const size_type n) const
Accessor< number, Constness > accessor
Iterator(const SparseMatrixIterators::Iterator< number, false > &i)
const Accessor< number, Constness > * operator->() const
Iterator(MatrixType *matrix, const std::size_t index_within_matrix)
const Iterator< number, Constness > & operator=(const SparseMatrixIterators::Iterator< number, false > &i)
typename Accessor< number, Constness >::MatrixType MatrixType
size_type difference_type
bool operator!=(const Iterator &) const
const Accessor< number, Constness > & operator*() const
void set(const size_type row, const std::vector< size_type > &col_indices, const std::vector< number2 > &values, const bool elide_zero_values=false)
somenumber matrix_scalar_product(const Vector< somenumber > &u, const Vector< somenumber > &v) const
void TSOR_step(Vector< somenumber > &v, const Vector< somenumber > &b, const number omega=1.) const
void precondition_Jacobi(Vector< somenumber > &dst, const Vector< somenumber > &src, const number omega=1.) const
SparseMatrix(const SparsityPattern &sparsity)
SparseMatrix< number > & copy_from(const SparseMatrix< somenumber > &source)
void add(const number factor, const SparseMatrix< somenumber > &matrix)
number & diag_element(const size_type i)
std::size_t n_nonzero_elements() const
size_type get_row_length(const size_type row) const
void SOR_step(Vector< somenumber > &v, const Vector< somenumber > &b, const number omega=1.) const
somenumber residual(Vector< somenumber > &dst, const Vector< somenumber > &x, const Vector< somenumber > &b) const
void Tmmult(SparseMatrix< numberC > &C, const SparseMatrix< numberB > &B, const Vector< number > &V=Vector< number >(), const bool rebuild_sparsity_pattern=true) const
void Tvmult(OutVector &dst, const InVector &src) const
const_iterator begin(const size_type r) const
const_iterator end() const
void SSOR_step(Vector< somenumber > &v, const Vector< somenumber > &b, const number omega=1.) const
void set(const std::vector< size_type > &indices, const FullMatrix< number2 > &full_matrix, const bool elide_zero_values=false)
void print_as_numpy_arrays(std::ostream &out, const unsigned int precision=9) const
SmartPointer< const SparsityPattern, SparseMatrix< number > > cols
void mmult(SparseMatrix< numberC > &C, const SparseMatrix< numberB > &B, const Vector< number > &V=Vector< number >(), const bool rebuild_sparsity_pattern=true) const
const number & operator()(const size_type i, const size_type j) const
void set(const size_type i, const size_type j, const number value)
void print_formatted(std::ostream &out, const unsigned int precision=3, const bool scientific=true, const unsigned int width=0, const char *zero_string=" ", const double denominator=1., const char *separator=" ") const
const_iterator begin() const
void precondition_TSOR(Vector< somenumber > &dst, const Vector< somenumber > &src, const number omega=1.) const
virtual ~SparseMatrix() override
void vmult_add(OutVector &dst, const InVector &src) const
number diag_element(const size_type i) const
SparseMatrix< number > & operator=(const SparseMatrix< number > &)
void add(const std::vector< size_type > &row_indices, const std::vector< size_type > &col_indices, const FullMatrix< number2 > &full_matrix, const bool elide_zero_values=true)
void SSOR(Vector< somenumber > &v, const number omega=1.) const
somenumber matrix_norm_square(const Vector< somenumber > &v) const
SparseMatrix(SparseMatrix< number > &&m) noexcept
void TSOR(Vector< somenumber > &v, const number omega=1.) const
SparseMatrix< number > & copy_from(const TrilinosWrappers::SparseMatrix &matrix)
SparseMatrix(const SparsityPattern &sparsity, const IdentityMatrix &id)
void print_pattern(std::ostream &out, const double threshold=0.) const
void vmult(OutVector &dst, const InVector &src) const
std::size_t memory_consumption() const
void PSOR(Vector< somenumber > &v, const std::vector< size_type > &permutation, const std::vector< size_type > &inverse_permutation, const number omega=1.) const
SparseMatrix & operator=(const double d)
void block_write(std::ostream &out) const
void copy_from(const ForwardIterator begin, const ForwardIterator end)
SparseMatrix & operator/=(const number factor)
void block_read(std::istream &in)
number el(const size_type i, const size_type j) const
void precondition_SSOR(Vector< somenumber > &dst, const Vector< somenumber > &src, const number omega=1., const std::vector< std::size_t > &pos_right_of_diagonal=std::vector< std::size_t >()) const
void print(StreamType &out, const bool across=false, const bool diagonal_first=true) const
const SparsityPattern & get_sparsity_pattern() const
const_iterator end(const size_type r) const
void SOR(Vector< somenumber > &v, const number omega=1.) const
std::unique_ptr< number[]> val
iterator begin(const size_type r)
void precondition_SOR(Vector< somenumber > &dst, const Vector< somenumber > &src, const number omega=1.) const
typename numbers::NumberTraits< number >::real_type real_type
types::global_dof_index size_type
void reinit(const SparseMatrix< number2 > &sparse_matrix)
number & operator()(const size_type i, const size_type j)
void add(const size_type row, const size_type n_cols, const size_type *col_indices, const number2 *values, const bool elide_zero_values=true, const bool col_indices_are_sorted=false)
void add(const size_type i, const size_type j, const number value)
void copy_from(const FullMatrix< somenumber > &matrix)
iterator end(const size_type r)
SparseMatrix< number > & operator=(SparseMatrix< number > &&m) noexcept
void compress(VectorOperation::values)
SparseMatrix(const SparseMatrix &)
real_type frobenius_norm() const
void Tvmult_add(OutVector &dst, const InVector &src) const
real_type linfty_norm() const
void add(const size_type row, const std::vector< size_type > &col_indices, const std::vector< number2 > &values, const bool elide_zero_values=true)
void set(const std::vector< size_type > &row_indices, const std::vector< size_type > &col_indices, const FullMatrix< number2 > &full_matrix, const bool elide_zero_values=false)
real_type l1_norm() const
SparseMatrix & operator*=(const number factor)
SparseMatrix< number > & operator=(const IdentityMatrix &id)
std::size_t n_actually_nonzero_elements(const double threshold=0.) const
void add(const std::vector< size_type > &indices, const FullMatrix< number2 > &full_matrix, const bool elide_zero_values=true)
void TPSOR(Vector< somenumber > &v, const std::vector< size_type > &permutation, const std::vector< size_type > &inverse_permutation, const number omega=1.) const
virtual void reinit(const SparsityPattern &sparsity)
void set(const size_type row, const size_type n_cols, const size_type *col_indices, const number2 *values, const bool elide_zero_values=false)
void Jacobi_step(Vector< somenumber > &v, const Vector< somenumber > &b, const number omega=1.) const
static constexpr size_type invalid_entry
std::enable_if_t< std::is_floating_point_v< T > &&std::is_floating_point_v< U >, typename ProductType< std::complex< T >, std::complex< U > >::type > operator*(const std::complex< T > &left, const std::complex< U > &right)
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
__global__ void set(Number *val, const Number s, const size_type N)
static ::ExceptionBase & ExcSourceEqualsDestination()
static ::ExceptionBase & ExcDivideByZero()
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcNotInitialized()
static ::ExceptionBase & ExcNeedsSparsityPattern()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
#define Assert(cond, exc)
static ::ExceptionBase & ExcDifferentSparsityPatterns()
static ::ExceptionBase & ExcIteratorRange(int arg1, int arg2)
#define AssertIsFinite(number)
#define DeclException2(Exception2, type1, type2, outsequence)
#define AssertIndexRange(index, range)
#define DeclExceptionMsg(Exception, defaulttext)
static ::ExceptionBase & ExcInvalidIndex(int arg1, int arg2)
static ::ExceptionBase & ExcNotQuadratic()
Expression operator>(const Expression &lhs, const Expression &rhs)
@ matrix
Contents is actually a matrix.
@ diagonal
Matrix is diagonal.
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
types::global_dof_index size_type
VectorType::value_type * begin(VectorType &V)
VectorType::value_type * end(VectorType &V)
T sum(const T &t, const MPI_Comm mpi_communicator)
void reinit(MatrixBlock< MatrixType > &v, const BlockSparsityPattern &p)
unsigned int global_dof_index
BarycentricPolynomial< dim, Number1 > operator+(const Number2 &a, const BarycentricPolynomial< dim, Number1 > &bp)
BarycentricPolynomial< dim, Number1 > operator-(const Number2 &a, const BarycentricPolynomial< dim, Number1 > &bp)
static const bool zero_addition_can_be_elided
typename ::SparseMatrixIterators::Iterator< number, Constness >::difference_type difference_type
forward_iterator_tag iterator_category
typename ::SparseMatrixIterators::Iterator< number, Constness >::value_type value_type
SynchronousIterators< Iterators > operator++(SynchronousIterators< Iterators > &a)
bool operator<(const SynchronousIterators< Iterators > &a, const SynchronousIterators< Iterators > &b)