# endif
#endif
-DEAL_II_NAMESPACE_CLOSE
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
-namespace std
+ namespace std
{
template <typename Number, std::size_t width>
- DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width>
- sqrt(const ::dealii::VectorizedArray<Number, width> &);
+ DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width> sqrt(
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, std::size_t width>
- DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width>
- abs(const ::dealii::VectorizedArray<Number, width> &);
+ DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width> abs(
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, std::size_t width>
- DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width>
- max(const ::dealii::VectorizedArray<Number, width> &,
- const ::dealii::VectorizedArray<Number, width> &);
+ DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width> max(
+ const ::dealii::VectorizedArray<Number, width> &,
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, std::size_t width>
- DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width>
- min(const ::dealii::VectorizedArray<Number, width> &,
- const ::dealii::VectorizedArray<Number, width> &);
+ DEAL_II_ALWAYS_INLINE ::dealii::VectorizedArray<Number, width> min(
+ const ::dealii::VectorizedArray<Number, width> &,
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, size_t width>
- ::dealii::VectorizedArray<Number, width>
- pow(const ::dealii::VectorizedArray<Number, width> &, const Number p);
+ ::dealii::VectorizedArray<Number, width> pow(
+ const ::dealii::VectorizedArray<Number, width> &, const Number p);
template <typename Number, size_t width>
- ::dealii::VectorizedArray<Number, width>
- sin(const ::dealii::VectorizedArray<Number, width> &);
+ ::dealii::VectorizedArray<Number, width> sin(
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, size_t width>
- ::dealii::VectorizedArray<Number, width>
- cos(const ::dealii::VectorizedArray<Number, width> &);
+ ::dealii::VectorizedArray<Number, width> cos(
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, size_t width>
- ::dealii::VectorizedArray<Number, width>
- tan(const ::dealii::VectorizedArray<Number, width> &);
+ ::dealii::VectorizedArray<Number, width> tan(
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, size_t width>
- ::dealii::VectorizedArray<Number, width>
- exp(const ::dealii::VectorizedArray<Number, width> &);
+ ::dealii::VectorizedArray<Number, width> exp(
+ const ::dealii::VectorizedArray<Number, width> &);
template <typename Number, size_t width>
- ::dealii::VectorizedArray<Number, width>
- log(const ::dealii::VectorizedArray<Number, width> &);
+ ::dealii::VectorizedArray<Number, width> log(
+ const ::dealii::VectorizedArray<Number, width> &);
} // namespace std
-DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
-/**
- * Namespace for the declaration of universal constants. Since the
- * availability in <tt>math.h</tt> is not always guaranteed, we put them here.
- * Since this file is included by <tt>base/config.h</tt>, they are available
- * to the whole library.
- *
- * The constants defined here are a subset of the <tt>M_XXX</tt> constants
- * sometimes declared in the system include file <tt>math.h</tt>, but without
- * the prefix <tt>M_</tt>.
- *
- * In addition to that, we declare <tt>invalid_unsigned_int</tt> to be the
- * largest unsigned integer representable; this value is widely used in the
- * library as a marker for an invalid index, an invalid size of an array, and
- * similar purposes.
- */
-namespace numbers
+ /**
+ * Namespace for the declaration of universal constants. Since the
+ * availability in <tt>math.h</tt> is not always guaranteed, we put them here.
+ * Since this file is included by <tt>base/config.h</tt>, they are available
+ * to the whole library.
+ *
+ * The constants defined here are a subset of the <tt>M_XXX</tt> constants
+ * sometimes declared in the system include file <tt>math.h</tt>, but without
+ * the prefix <tt>M_</tt>.
+ *
+ * In addition to that, we declare <tt>invalid_unsigned_int</tt> to be the
+ * largest unsigned integer representable; this value is widely used in the
+ * library as a marker for an invalid index, an invalid size of an array, and
+ * similar purposes.
+ */
+ namespace numbers
{
/**
* e
* double</code>, this function may return <code>false</code> even if the
* number is finite with respect to type <code>long double</code>.
*/
- bool
- is_finite(const double x);
+ bool is_finite(const double x);
/**
* Return @p true if real and imaginary parts of the given complex number
* are finite.
*/
- bool
- is_finite(const std::complex<double> &x);
+ bool is_finite(const std::complex<double> &x);
/**
* Return @p true if real and imaginary parts of the given complex number
* are finite.
*/
- bool
- is_finite(const std::complex<float> &x);
+ bool is_finite(const std::complex<float> &x);
/**
* Return @p true if real and imaginary parts of the given complex number
* numbers that are infinite in terms of <code>double</code>, but finite
* with respect to <code>long double</code>.
*/
- bool
- is_finite(const std::complex<long double> &x);
+ bool is_finite(const std::complex<long double> &x);
/**
* Return whether two numbers are equal to one another.
* of @p value_1.
*/
template <typename Number1, typename Number2>
- constexpr DEAL_II_HOST_DEVICE bool
- values_are_equal(const Number1 &value_1, const Number2 &value_2);
+ constexpr DEAL_II_HOST_DEVICE bool values_are_equal(const Number1 &value_1,
+ const Number2 &value_2);
/**
* Return whether two numbers are not equal to one another.
* of @p value_1.
*/
template <typename Number1, typename Number2>
- constexpr bool
- values_are_not_equal(const Number1 &value_1, const Number2 &value_2);
+ constexpr bool values_are_not_equal(const Number1 &value_1,
+ const Number2 &value_2);
/**
* Return whether or not a value is equal to zero.
* by the input arguments.
*/
template <typename Number>
- constexpr DEAL_II_HOST_DEVICE bool
- value_is_zero(const Number &value);
+ constexpr DEAL_II_HOST_DEVICE bool value_is_zero(const Number &value);
/**
* Return whether @p value_1 is less than that of @p value_2.
* of @p value_1.
*/
template <typename Number1, typename Number2>
- bool
- value_is_less_than(const Number1 &value_1, const Number2 &value_2);
+ bool value_is_less_than(const Number1 &value_1, const Number2 &value_2);
/**
* Return whether @p value_1 is less than or equal to that of @p value_2.
* of @p value_1.
*/
template <typename Number1, typename Number2>
- bool
- value_is_less_than_or_equal_to(const Number1 &value_1,
- const Number2 &value_2);
+ bool value_is_less_than_or_equal_to(const Number1 &value_1,
+ const Number2 &value_2);
* of @p value_1.
*/
template <typename Number1, typename Number2>
- bool
- value_is_greater_than(const Number1 &value_1, const Number2 &value_2);
+ bool value_is_greater_than(const Number1 &value_1, const Number2 &value_2);
/**
* Return whether @p value_1 is greater than or equal to that of @p value_2.
* of @p value_1.
*/
template <typename Number1, typename Number2>
- bool
- value_is_greater_than_or_equal_to(const Number1 &value_1,
- const Number2 &value_2);
+ bool value_is_greater_than_or_equal_to(const Number1 &value_1,
+ const Number2 &value_2);
/**
* A structure that, together with its partial specializations
// --------------- inline and template functions ---------------- //
- inline bool
- is_nan(const double x)
+ inline bool is_nan(const double x)
{
return std::isnan(x);
}
- inline bool
- is_finite(const double x)
+ inline bool is_finite(const double x)
{
return std::isfinite(x);
}
- inline bool
- is_finite(const std::complex<double> &x)
+ inline bool is_finite(const std::complex<double> &x)
{
// Check complex numbers for infinity
// by testing real and imaginary part
- inline bool
- is_finite(const std::complex<float> &x)
+ inline bool is_finite(const std::complex<float> &x)
{
// Check complex numbers for infinity
// by testing real and imaginary part
- inline bool
- is_finite(const std::complex<long double> &x)
+ inline bool is_finite(const std::complex<long double> &x)
{
// Same for std::complex<long double>
return (is_finite(x.real()) && is_finite(x.imag()));
template <typename number>
- constexpr DEAL_II_HOST_DEVICE const number &
- NumberTraits<number>::conjugate(const number &x)
+ constexpr DEAL_II_HOST_DEVICE const number &NumberTraits<number>::conjugate(
+ const number &x)
{
return x;
}
template <typename number>
- typename NumberTraits<number>::real_type
- NumberTraits<number>::abs(const number &x)
+ typename NumberTraits<number>::real_type NumberTraits<number>::abs(
+ const number &x)
{
// Make things work with AD types
using std::abs;
template <typename number>
- constexpr std::complex<number>
- NumberTraits<std::complex<number>>::conjugate(const std::complex<number> &x)
+ constexpr std::complex<number> NumberTraits<std::complex<number>>::conjugate(
+ const std::complex<number> &x)
{
return std::conj(x);
}
#include <boost/geometry/strategies/strategies.hpp>
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-namespace boost
+
+DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
+
+ namespace boost
{
namespace geometry
{
} // namespace geometry
} // namespace boost
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
+ DEAL_II_NAMESPACE_CLOSE
+
#endif
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
-namespace boost
+DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
+
+ namespace boost
{
namespace geometry
{
} // namespace geometry
} // namespace boost
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
+ DEAL_II_NAMESPACE_CLOSE
#endif
} // namespace ChunkSparseMatrixIterators
-DEAL_II_NAMESPACE_CLOSE
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
-namespace std
+ namespace std
{
template <typename number, bool Constness>
struct iterator_traits<
};
} // namespace std
-DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
-/**
- * Sparse matrix. This class implements the function to store values in the
- * locations of a sparse matrix denoted by a SparsityPattern. The separation
- * of sparsity pattern and values is done since one can store data elements of
- * different type in these locations without the SparsityPattern having to
- * know this, and more importantly one can associate more than one matrix with
- * the same sparsity pattern.
- *
- * The use of this class is demonstrated in step-51.
- *
- * @note Instantiations for this template are provided for <tt>@<float@> and
- * @<double@></tt>; others can be generated in application programs (see the
- * section on
- * @ref Instantiations
- * in the manual).
- */
-template <typename number>
-class ChunkSparseMatrix : public virtual EnableObserverPointer
+ /**
+ * Sparse matrix. This class implements the function to store values in the
+ * locations of a sparse matrix denoted by a SparsityPattern. The separation
+ * of sparsity pattern and values is done since one can store data elements of
+ * different type in these locations without the SparsityPattern having to
+ * know this, and more importantly one can associate more than one matrix with
+ * the same sparsity pattern.
+ *
+ * The use of this class is demonstrated in step-51.
+ *
+ * @note Instantiations for this template are provided for <tt>@<float@> and
+ * @<double@></tt>; others can be generated in application programs (see the
+ * section on
+ * @ref Instantiations
+ * in the manual).
+ */
+ template <typename number>
+ class ChunkSparseMatrix : public virtual EnableObserverPointer
{
public:
/**
# include <cfenv>
#endif
+DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
+
+
// DEAL_II_FORTRAN_MANGLE confuses doxygen a lot and these functions aren't part
// of our public API anyway, so don't generate any doxygen for them
#ifndef DOXYGEN
-extern "C"
+ extern "C"
{
void DEAL_II_FORTRAN_MANGLE(saxpy,
SAXPY)(const dealii::types::blas_int *n,
}
#endif
-DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
-template <typename number1, typename number2, typename number3>
-inline void
-axpy(const dealii::types::blas_int *,
- const number1 *,
- const number2 *,
- const dealii::types::blas_int *,
- number3 *,
- const dealii::types::blas_int *)
+ template <typename number1, typename number2, typename number3>
+ inline void
+ axpy(const dealii::types::blas_int *,
+ const number1 *,
+ const number2 *,
+ const dealii::types::blas_int *,
+ number3 *,
+ const dealii::types::blas_int *)
{
DEAL_II_NOT_IMPLEMENTED();
}
} // namespace SparseMatrixIterators
-DEAL_II_NAMESPACE_CLOSE
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
-namespace std
+ namespace std
{
template <typename number, bool Constness>
struct iterator_traits<
};
} // namespace std
-DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
-/**
- * @}
- */
+ /**
+ * @}
+ */
-// TODO: Add multithreading to the other vmult functions.
+ // TODO: Add multithreading to the other vmult functions.
-/**
- * Sparse matrix. This class implements the functionality to store matrix
- * entry values in the locations denoted by a SparsityPattern. See
- * @ref Sparsity
- * for a discussion about the separation between sparsity patterns and
- * matrices.
- *
- * The elements of a SparseMatrix are stored in the same order in which the
- * SparsityPattern class stores its entries. Within each row, elements are
- * generally stored left-to-right in increasing column index order; the
- * exception to this rule is that if the matrix is square (m() == n()), then
- * the diagonal entry is stored as the first element in each row to make
- * operations like applying a Jacobi or SSOR preconditioner faster. As a
- * consequence, if you traverse the elements of a row of a SparseMatrix with
- * the help of iterators into this object (using SparseMatrix::begin and
- * SparseMatrix::end) you will find that the elements are not sorted by column
- * index within each row whenever the matrix is square.
- *
- * @note Instantiations for this template are provided for <tt>@<float@> and
- * @<double@></tt>; others can be generated in application programs (see the
- * section on
- * @ref Instantiations
- * in the manual).
- *
- * @ingroup Matrix1
- */
-template <typename number>
-class SparseMatrix : public virtual EnableObserverPointer
+ /**
+ * Sparse matrix. This class implements the functionality to store matrix
+ * entry values in the locations denoted by a SparsityPattern. See
+ * @ref Sparsity
+ * for a discussion about the separation between sparsity patterns and
+ * matrices.
+ *
+ * The elements of a SparseMatrix are stored in the same order in which the
+ * SparsityPattern class stores its entries. Within each row, elements are
+ * generally stored left-to-right in increasing column index order; the
+ * exception to this rule is that if the matrix is square (m() == n()), then
+ * the diagonal entry is stored as the first element in each row to make
+ * operations like applying a Jacobi or SSOR preconditioner faster. As a
+ * consequence, if you traverse the elements of a row of a SparseMatrix with
+ * the help of iterators into this object (using SparseMatrix::begin and
+ * SparseMatrix::end) you will find that the elements are not sorted by column
+ * index within each row whenever the matrix is square.
+ *
+ * @note Instantiations for this template are provided for <tt>@<float@> and
+ * @<double@></tt>; others can be generated in application programs (see the
+ * section on
+ * @ref Instantiations
+ * in the manual).
+ *
+ * @ingroup Matrix1
+ */
+ template <typename number>
+ class SparseMatrix : public virtual EnableObserverPointer
{
public:
/**
} // namespace SparseMatrixIterators
} // namespace TrilinosWrappers
-DEAL_II_NAMESPACE_CLOSE
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
-namespace std
+ namespace std
{
template <bool Constness>
struct iterator_traits<
};
} // namespace std
-DEAL_II_NAMESPACE_OPEN
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
-namespace TrilinosWrappers
+ namespace TrilinosWrappers
{
/**
* This class implements a wrapper to use the Trilinos distributed sparse
- inline SparseMatrix::const_iterator
- SparseMatrix::begin() const
+ inline SparseMatrix::const_iterator SparseMatrix::begin() const
{
return begin(0);
}
- inline SparseMatrix::const_iterator
- SparseMatrix::end() const
+ inline SparseMatrix::const_iterator SparseMatrix::end() const
{
return const_iterator(this, m(), 0);
}
- inline SparseMatrix::const_iterator
- SparseMatrix::begin(const size_type r) const
+ inline SparseMatrix::const_iterator SparseMatrix::begin(const size_type r)
+ const
{
AssertIndexRange(r, m());
if (in_local_range(r) && (row_length(r) > 0))
- inline SparseMatrix::const_iterator
- SparseMatrix::end(const size_type r) const
+ inline SparseMatrix::const_iterator SparseMatrix::end(const size_type r) const
{
AssertIndexRange(r, m());
- inline SparseMatrix::iterator
- SparseMatrix::begin()
+ inline SparseMatrix::iterator SparseMatrix::begin()
{
return begin(0);
}
- inline SparseMatrix::iterator
- SparseMatrix::end()
+ inline SparseMatrix::iterator SparseMatrix::end()
{
return iterator(this, m(), 0);
}
- inline SparseMatrix::iterator
- SparseMatrix::begin(const size_type r)
+ inline SparseMatrix::iterator SparseMatrix::begin(const size_type r)
{
AssertIndexRange(r, m());
if (in_local_range(r) && (row_length(r) > 0))
- inline SparseMatrix::iterator
- SparseMatrix::end(const size_type r)
+ inline SparseMatrix::iterator SparseMatrix::end(const size_type r)
{
AssertIndexRange(r, m());
- inline bool
- SparseMatrix::in_local_range(const size_type index) const
+ inline bool SparseMatrix::in_local_range(const size_type index) const
{
TrilinosWrappers::types::int_type begin, end;
# ifndef DEAL_II_WITH_64BIT_INDICES
- inline bool
- SparseMatrix::is_compressed() const
+ inline bool SparseMatrix::is_compressed() const
{
return compressed;
}
// frequently, and the compiler can optimize away some unnecessary loops
// when the sizes are given at compile time.
template <>
- void
- SparseMatrix::set<TrilinosScalar>(const size_type row,
- const size_type n_cols,
- const size_type *col_indices,
- const TrilinosScalar *values,
- const bool elide_zero_values);
+ void SparseMatrix::set<TrilinosScalar>(const size_type row,
+ const size_type n_cols,
+ const size_type *col_indices,
+ const TrilinosScalar *values,
+ const bool elide_zero_values);
template <typename Number>
- void
- SparseMatrix::set(const size_type row,
- const size_type n_cols,
- const size_type *col_indices,
- const Number *values,
- const bool elide_zero_values)
+ void SparseMatrix::set(const size_type row,
+ const size_type n_cols,
+ const size_type *col_indices,
+ const Number *values,
+ const bool elide_zero_values)
{
std::vector<TrilinosScalar> trilinos_values(n_cols);
std::copy(values, values + n_cols, trilinos_values.begin());
- inline void
- SparseMatrix::set(const size_type i,
- const size_type j,
- const TrilinosScalar value)
+ inline void SparseMatrix::set(const size_type i,
+ const size_type j,
+ const TrilinosScalar value)
{
AssertIsFinite(value);
- inline void
- SparseMatrix::set(const std::vector<size_type> &indices,
- const FullMatrix<TrilinosScalar> &values,
- const bool elide_zero_values)
+ inline void SparseMatrix::set(const std::vector<size_type> &indices,
+ const FullMatrix<TrilinosScalar> &values,
+ const bool elide_zero_values)
{
Assert(indices.size() == values.m(),
ExcDimensionMismatch(indices.size(), values.m()));
- inline void
- SparseMatrix::add(const size_type i,
- const size_type j,
- const TrilinosScalar value)
+ inline void SparseMatrix::add(const size_type i,
+ const size_type j,
+ const TrilinosScalar value)
{
AssertIsFinite(value);
// inline "simple" functions that are called frequently and do only involve
// a call to some Trilinos function.
- inline SparseMatrix::size_type
- SparseMatrix::m() const
+ inline SparseMatrix::size_type SparseMatrix::m() const
{
# ifndef DEAL_II_WITH_64BIT_INDICES
return matrix->NumGlobalRows();
- inline SparseMatrix::size_type
- SparseMatrix::n() const
+ inline SparseMatrix::size_type SparseMatrix::n() const
{
// If the matrix structure has not been fixed (i.e., we did not have a
// sparsity pattern), it does not know about the number of columns so we
- inline unsigned int
- SparseMatrix::local_size() const
+ inline unsigned int SparseMatrix::local_size() const
{
return matrix->NumMyRows();
}
- inline std::uint64_t
- SparseMatrix::n_nonzero_elements() const
+ inline std::uint64_t SparseMatrix::n_nonzero_elements() const
{
// Trilinos uses 64bit functions internally for attribute access, which
// return `long long`. They also offer 32bit variants that return `int`,
template <typename SparsityPatternType>
- inline void
- SparseMatrix::reinit(const IndexSet ¶llel_partitioning,
- const SparsityPatternType &sparsity_pattern,
- const MPI_Comm communicator,
- const bool exchange_data)
+ inline void SparseMatrix::reinit(const IndexSet ¶llel_partitioning,
+ const SparsityPatternType &sparsity_pattern,
+ const MPI_Comm communicator,
+ const bool exchange_data)
{
reinit(parallel_partitioning,
parallel_partitioning,
template <typename number>
- inline void
- SparseMatrix::reinit(const IndexSet ¶llel_partitioning,
- const ::dealii::SparseMatrix<number> &sparse_matrix,
- const MPI_Comm communicator,
- const double drop_tolerance,
- const bool copy_values,
- const ::dealii::SparsityPattern *use_this_sparsity)
+ inline void SparseMatrix::reinit(
+ const IndexSet ¶llel_partitioning,
+ const ::dealii::SparseMatrix<number> &sparse_matrix,
+ const MPI_Comm communicator,
+ const double drop_tolerance,
+ const bool copy_values,
+ const ::dealii::SparsityPattern *use_this_sparsity)
{
Epetra_Map map =
parallel_partitioning.make_trilinos_map(communicator, false);
- inline const Epetra_CrsMatrix &
- SparseMatrix::trilinos_matrix() const
+ inline const Epetra_CrsMatrix &SparseMatrix::trilinos_matrix() const
{
return static_cast<const Epetra_CrsMatrix &>(*matrix);
}
- inline const Epetra_CrsGraph &
- SparseMatrix::trilinos_sparsity_pattern() const
+ inline const Epetra_CrsGraph &SparseMatrix::trilinos_sparsity_pattern() const
{
return matrix->Graph();
}
- inline IndexSet
- SparseMatrix::locally_owned_domain_indices() const
+ inline IndexSet SparseMatrix::locally_owned_domain_indices() const
{
return IndexSet(matrix->DomainMap());
}
- inline IndexSet
- SparseMatrix::locally_owned_range_indices() const
+ inline IndexSet SparseMatrix::locally_owned_range_indices() const
{
return IndexSet(matrix->RangeMap());
}
- inline void
- SparseMatrix::prepare_add()
+ inline void SparseMatrix::prepare_add()
{
// nothing to do here
}
- inline void
- SparseMatrix::prepare_set()
+ inline void SparseMatrix::prepare_set()
{
// nothing to do here
}
template <typename VectorType>
- inline TrilinosScalar
- SparseMatrix::residual(VectorType &dst,
- const VectorType &x,
- const VectorType &b) const
+ inline TrilinosScalar SparseMatrix::residual(VectorType & dst,
+ const VectorType &x,
+ const VectorType &b) const
{
vmult(dst, x);
dst -= b;
} // namespace internal
template <>
- void
- SparseMatrix::set<TrilinosScalar>(const size_type row,
- const size_type n_cols,
- const size_type *col_indices,
- const TrilinosScalar *values,
- const bool elide_zero_values);
+ void SparseMatrix::set<TrilinosScalar>(const size_type row,
+ const size_type n_cols,
+ const size_type *col_indices,
+ const TrilinosScalar *values,
+ const bool elide_zero_values);
# endif // DOXYGEN
} /* namespace TrilinosWrappers */
} // namespace Particles
-DEAL_II_NAMESPACE_CLOSE
+DEAL_II_NAMESPACE_CLOSE // Do not convert for module purposes
-namespace boost
+ namespace boost
{
namespace geometry
{
} // namespace geometry
} // namespace boost
+
+DEAL_II_NAMESPACE_OPEN // Do not convert for module purposes
+ DEAL_II_NAMESPACE_CLOSE
+
#endif