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>
472 struct iterator_traits<
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 <
class StreamType>
1583 const bool across =
false,
1584 const bool diagonal_first =
true)
const;
1608 const unsigned int precision = 3,
1609 const bool scientific =
true,
1610 const unsigned int width = 0,
1611 const char * zero_string =
" ",
1612 const double denominator = 1.)
const;
1632 const unsigned int precision = 9)
const;
1677 <<
"You are trying to access the matrix entry with index <"
1678 << arg1 <<
',' << arg2
1679 <<
">, but this entry does not exist in the sparsity pattern "
1682 "The most common cause for this problem is that you used "
1683 "a method to build the sparsity pattern that did not "
1684 "(completely) take into account all of the entries you "
1685 "will later try to write into. An example would be "
1686 "building a sparsity pattern that does not include "
1687 "the entries you will write into due to constraints "
1688 "on degrees of freedom such as hanging nodes or periodic "
1689 "boundary conditions. In such cases, building the "
1690 "sparsity pattern will succeed, but you will get errors "
1691 "such as the current one at one point or other when "
1692 "trying to write into the entries of the matrix.");
1697 "When copying one sparse matrix into another, "
1698 "or when adding one sparse matrix to another, "
1699 "both matrices need to refer to the same "
1700 "sparsity pattern.");
1707 <<
"The iterators denote a range of " << arg1
1708 <<
" elements, but the given number of rows was " << arg2);
1713 "You are attempting an operation on two vectors that "
1714 "are the same object, but the operation requires that the "
1715 "two objects are in fact different.");
1754 std::unique_ptr<number[]>
val;
1765 template <
typename somenumber>
1767 template <
typename somenumber>
1777 template <
typename,
bool>
1779 template <
typename,
bool>
1782 #ifdef DEAL_II_WITH_MPI
1784 template <
typename Number>
1797 template <
typename number>
1798 template <
typename number2>
1807 template <
typename number>
1816 template <
typename number>
1826 template <
typename number>
1841 ExcInvalidIndex(i, j));
1850 template <
typename number>
1851 template <
typename number2>
1855 const bool elide_zero_values)
1861 for (
size_type i = 0; i < indices.size(); ++i)
1871 template <
typename number>
1872 template <
typename number2>
1875 const std::vector<size_type> &col_indices,
1877 const bool elide_zero_values)
1884 for (
size_type i = 0; i < row_indices.size(); ++i)
1894 template <
typename number>
1895 template <
typename number2>
1898 const std::vector<size_type> &col_indices,
1899 const std::vector<number2> &
values,
1900 const bool elide_zero_values)
1914 template <
typename number>
1922 if (
value == number())
1932 ExcInvalidIndex(i, j));
1941 template <
typename number>
1942 template <
typename number2>
1946 const bool elide_zero_values)
1952 for (
size_type i = 0; i < indices.size(); ++i)
1962 template <
typename number>
1963 template <
typename number2>
1966 const std::vector<size_type> &col_indices,
1968 const bool elide_zero_values)
1975 for (
size_type i = 0; i < row_indices.size(); ++i)
1985 template <
typename number>
1986 template <
typename number2>
1989 const std::vector<size_type> &col_indices,
1990 const std::vector<number2> &
values,
1991 const bool elide_zero_values)
2005 template <
typename number>
2012 number * val_ptr = val.get();
2013 const number *
const end_ptr = val.get() + cols->n_nonzero_elements();
2015 while (val_ptr != end_ptr)
2016 *val_ptr++ *= factor;
2023 template <
typename number>
2031 const number factor_inv = number(1.) / factor;
2033 number * val_ptr = val.get();
2034 const number *
const end_ptr = val.get() + cols->n_nonzero_elements();
2036 while (val_ptr != end_ptr)
2037 *val_ptr++ *= factor_inv;
2044 template <
typename number>
2045 inline const number &
2050 ExcInvalidIndex(i, j));
2051 return val[cols->operator()(i, j)];
2056 template <
typename number>
2062 ExcInvalidIndex(i, j));
2063 return val[cols->operator()(i, j)];
2068 template <
typename number>
2083 template <
typename number>
2093 return val[cols->rowstart[i]];
2098 template <
typename number>
2108 return val[cols->rowstart[i]];
2113 template <
typename number>
2114 template <
typename ForwardIterator>
2117 const ForwardIterator
end)
2120 ExcIteratorRange(std::distance(
begin,
end), m()));
2124 using inner_iterator =
2125 typename std::iterator_traits<ForwardIterator>::value_type::const_iterator;
2127 for (ForwardIterator i =
begin; i !=
end; ++i, ++
row)
2129 const inner_iterator end_of_row = i->end();
2130 for (inner_iterator j = i->begin(); j != end_of_row; ++j)
2132 set(
row, j->first, j->second);
2142 template <
typename number>
2144 const std::size_t index_within_matrix)
2146 index_within_matrix)
2152 template <
typename number>
2153 inline Accessor<number, true>::Accessor(
const MatrixType *
matrix)
2160 template <
typename number>
2161 inline Accessor<number, true>::Accessor(
2164 ,
matrix(&a.get_matrix())
2169 template <
typename number>
2171 Accessor<number, true>::value()
const
2174 return matrix->val[linear_index];
2179 template <
typename number>
2180 inline const typename Accessor<number, true>::MatrixType &
2181 Accessor<number, true>::get_matrix()
const
2188 template <
typename number>
2189 inline Accessor<number, false>::Reference::Reference(
const Accessor *accessor,
2191 : accessor(accessor)
2195 template <
typename number>
2196 inline Accessor<number, false>::Reference::operator number()
const
2199 accessor->matrix->n_nonzero_elements());
2200 return accessor->matrix->val[accessor->linear_index];
2205 template <
typename number>
2206 inline const typename Accessor<number, false>::Reference &
2207 Accessor<number, false>::Reference::operator=(
const number n)
const
2210 accessor->matrix->n_nonzero_elements());
2211 accessor->matrix->val[accessor->linear_index] = n;
2217 template <
typename number>
2218 inline const typename Accessor<number, false>::Reference &
2219 Accessor<number, false>::Reference::operator+=(
const number n)
const
2222 accessor->matrix->n_nonzero_elements());
2223 accessor->matrix->val[accessor->linear_index] += n;
2229 template <
typename number>
2230 inline const typename Accessor<number, false>::Reference &
2231 Accessor<number, false>::Reference::operator-=(
const number n)
const
2234 accessor->matrix->n_nonzero_elements());
2235 accessor->matrix->val[accessor->linear_index] -= n;
2241 template <
typename number>
2242 inline const typename Accessor<number, false>::Reference &
2243 Accessor<number, false>::Reference::operator*=(
const number n)
const
2246 accessor->matrix->n_nonzero_elements());
2247 accessor->matrix->val[accessor->linear_index] *= n;
2253 template <
typename number>
2254 inline const typename Accessor<number, false>::Reference &
2255 Accessor<number, false>::Reference::operator/=(
const number n)
const
2258 accessor->matrix->n_nonzero_elements());
2259 accessor->matrix->val[accessor->linear_index] /= n;
2265 template <
typename number>
2266 inline Accessor<number, false>::Accessor(MatrixType *
matrix,
2267 const std::size_t index)
2274 template <
typename number>
2275 inline Accessor<number, false>::Accessor(MatrixType *
matrix)
2282 template <
typename number>
2283 inline typename Accessor<number, false>::Reference
2284 Accessor<number, false>::value()
const
2286 return Reference(
this,
true);
2291 template <
typename number>
2292 inline typename Accessor<number, false>::MatrixType &
2293 Accessor<number, false>::get_matrix()
const
2300 template <
typename number,
bool Constness>
2301 inline Iterator<number, Constness>::Iterator(MatrixType *
matrix,
2302 const std::size_t index)
2308 template <
typename number,
bool Constness>
2309 inline Iterator<number, Constness>::Iterator(MatrixType *
matrix)
2315 template <
typename number,
bool Constness>
2316 inline Iterator<number, Constness>::Iterator(
2323 template <
typename number,
bool Constness>
2324 inline const Iterator<number, Constness> &
2325 Iterator<number, Constness>::operator=(
2334 template <
typename number,
bool Constness>
2335 inline Iterator<number, Constness> &
2343 template <
typename number,
bool Constness>
2344 inline Iterator<number, Constness>
2347 const Iterator iter = *
this;
2353 template <
typename number,
bool Constness>
2354 inline const Accessor<number, Constness> &
2361 template <
typename number,
bool Constness>
2362 inline const Accessor<number, Constness> *
2363 Iterator<number, Constness>::operator->()
const
2369 template <
typename number,
bool Constness>
2373 return (accessor == other.accessor);
2377 template <
typename number,
bool Constness>
2381 return !(*
this == other);
2385 template <
typename number,
bool Constness>
2389 Assert(&accessor.get_matrix() == &other.accessor.get_matrix(),
2392 return (accessor < other.accessor);
2396 template <
typename number,
bool Constness>
2400 return (other < *
this);
2404 template <
typename number,
bool Constness>
2408 Assert(&accessor.get_matrix() == &other.accessor.get_matrix(),
2411 return (*this)->linear_index - other->linear_index;
2416 template <
typename number,
bool Constness>
2417 inline Iterator<number, Constness>
2431 template <
typename number>
2435 return const_iterator(
this, 0);
2439 template <
typename number>
2443 return const_iterator(
this);
2447 template <
typename number>
2451 return iterator(
this, 0);
2455 template <
typename number>
2459 return iterator(
this, cols->rowstart[cols->rows]);
2463 template <
typename number>
2469 return const_iterator(
this, cols->rowstart[r]);
2474 template <
typename number>
2480 return const_iterator(
this, cols->rowstart[r + 1]);
2485 template <
typename number>
2491 return iterator(
this, cols->rowstart[r]);
2496 template <
typename number>
2502 return iterator(
this, cols->rowstart[r + 1]);
2507 template <
typename number>
2508 template <
class StreamType>
2512 const bool diagonal_first)
const
2517 bool hanging_diagonal =
false;
2520 for (
size_type i = 0; i < cols->rows; ++i)
2522 for (
size_type j = cols->rowstart[i]; j < cols->rowstart[i + 1]; ++j)
2524 if (!diagonal_first && i == cols->colnums[j])
2527 hanging_diagonal =
true;
2531 if (hanging_diagonal && cols->colnums[j] > i)
2534 out <<
' ' << i <<
',' << i <<
':' <<
diagonal;
2536 out <<
'(' << i <<
',' << i <<
") " <<
diagonal
2538 hanging_diagonal =
false;
2541 out <<
' ' << i <<
',' << cols->colnums[j] <<
':' << val[j];
2543 out <<
'(' << i <<
',' << cols->colnums[j] <<
") " << val[j]
2547 if (hanging_diagonal)
2550 out <<
' ' << i <<
',' << i <<
':' <<
diagonal;
2552 out <<
'(' << i <<
',' << i <<
") " <<
diagonal << std::endl;
2553 hanging_diagonal =
false;
2561 template <
typename number>
2570 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)
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
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
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< T >::value &&std::is_floating_point< U >::value, 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)