is_type(const unsigned int i) const;
/// List the contents to a stream
- template <class StreamType>
+ template <typename StreamType>
void
list(StreamType &os) const;
}
-template <class StreamType>
+template <typename StreamType>
inline void
AnyData::list(StreamType &os) const
{
*
* @ref ExceptionBase
*/
- template <class ExceptionType>
+ template <typename ExceptionType>
[[noreturn]] void
issue_error_noreturn(ExceptionHandling handling,
const char * file,
* @note This function is defined with a template for the same reasons as
* issue_error_noreturn().
*/
- template <class ExceptionType>
+ template <typename ExceptionType>
void
issue_error_nothrow(const char * file,
int line,
* Output a text representation of this IndexSet to the given stream. Used
* for testing.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print(StreamType &out) const;
-template <class StreamType>
+template <typename StreamType>
inline void
IndexSet::print(StreamType &out) const
{
*
* @note TransposeTable uses this template to implement its iterators.
*/
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
class LinearIndexIterator
{
public:
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator=(
const DerivedIterator &it)
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator++()
{
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::operator++(int)
{
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator--()
{
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::operator--(int)
{
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::operator+(
const difference_type n) const
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::operator-(
const difference_type n) const
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator+=(
const difference_type n)
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator-=(
const difference_type n)
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline
typename LinearIndexIterator<DerivedIterator, AccessorType>::difference_type
LinearIndexIterator<DerivedIterator, AccessorType>::operator-(
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline typename LinearIndexIterator<DerivedIterator, AccessorType>::reference
LinearIndexIterator<DerivedIterator, AccessorType>::operator*() const
{
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline typename LinearIndexIterator<DerivedIterator, AccessorType>::pointer
LinearIndexIterator<DerivedIterator, AccessorType>::operator->() const
{
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline bool
LinearIndexIterator<DerivedIterator, AccessorType>::operator<=(
const DerivedIterator &other) const
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline bool
LinearIndexIterator<DerivedIterator, AccessorType>::operator>=(
const DerivedIterator &other) const
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline bool
LinearIndexIterator<DerivedIterator, AccessorType>::operator<(
const DerivedIterator &other) const
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline bool
LinearIndexIterator<DerivedIterator, AccessorType>::operator>(
const DerivedIterator &other) const
-template <class DerivedIterator, class AccessorType>
+template <typename DerivedIterator, typename AccessorType>
inline LinearIndexIterator<DerivedIterator, AccessorType>::LinearIndexIterator(
const AccessorType accessor)
: accessor(accessor)
* Construct a MutableBind object specifying the function, and
* each arguments separately.
*/
- template <class FunctionType>
+ template <typename FunctionType>
MutableBind(FunctionType function, FunctionArgs &&...arguments);
/**
* Construct a MutableBind object specifying the function, and
* the arguments as a tuple.
*/
- template <class FunctionType>
+ template <typename FunctionType>
MutableBind(FunctionType function, TupleType &&arguments);
/**
* Construct a MutableBind object specifying only the function. By default,
* the arguments are left to their default constructor values.
*/
- template <class FunctionType>
+ template <typename FunctionType>
MutableBind(FunctionType function);
/**
#ifndef DOXYGEN
template <typename ReturnType, class... FunctionArgs>
- template <class FunctionType>
+ template <typename FunctionType>
MutableBind<ReturnType, FunctionArgs...>::MutableBind(
FunctionType function,
FunctionArgs &&...arguments)
template <typename ReturnType, class... FunctionArgs>
- template <class FunctionType>
+ template <typename FunctionType>
MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function,
TupleType && arguments)
: function(function)
template <typename ReturnType, class... FunctionArgs>
- template <class FunctionType>
+ template <typename FunctionType>
MutableBind<ReturnType, FunctionArgs...>::MutableBind(FunctionType function)
: function(function)
{}
* See the documentation of ParameterHandler::add_parameter() for more
* information.
*/
- template <class ParameterType>
+ template <typename ParameterType>
void
add_parameter(const std::string & entry,
ParameterType & parameter,
// Inline and template functions
-template <class ParameterType>
+template <typename ParameterType>
void
ParameterAcceptor::add_parameter(const std::string & entry,
ParameterType & parameter,
* successfully can be queried by the functions get_entries_wrongly_not_set()
* and assert_that_entries_have_been_set().
*/
- template <class ParameterType>
+ template <typename ParameterType>
void
add_parameter(const std::string & entry,
ParameterType & parameter,
}
-template <class ParameterType>
+template <typename ParameterType>
void
ParameterHandler::add_parameter(const std::string & entry,
ParameterType & parameter,
/**
* Show the paths and suffixes used for this object.
*/
- template <class StreamType>
+ template <typename StreamType>
void
show(StreamType &stream) const;
/* ----------------------------- inline functions ------------------------- */
-template <class StreamType>
+template <typename StreamType>
inline void
PathSearch::show(StreamType &out) const
{
};
// std::array
- template <class ValueType, std::size_t N>
+ template <typename ValueType, std::size_t N>
struct Convert<std::array<ValueType, N>>
{
using T = std::array<ValueType, N>;
/**
* Prints the list of the indices to <tt>out</tt>.
*/
- template <class StreamType>
+ template <typename StreamType>
void
output_indices(StreamType &out) const;
template <int dim>
-template <class StreamType>
+template <typename StreamType>
void
PolynomialSpace<dim>::output_indices(StreamType &out) const
{
* parameter pack are equal to the `Type` given as first template
* argument. The result is stored in the member variable `value`.
*/
-template <class Type, class... Types>
+template <typename Type, class... Types>
struct all_same_as
{
static constexpr bool value = internal::TemplateConstraints::all_true<
* parameter pack are equal to the `Type` given as first template
* argument. The result is stored in the member variable `value`.
*/
-template <class Type, class... Types>
+template <typename Type, class... Types>
struct is_same_as_any_of
{
static constexpr bool value = internal::TemplateConstraints::any_true<
* Print the data returned by Timer::get_last_lap_wall_time_data() to the
* given stream.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print_last_lap_wall_time_data(StreamType &stream) const;
* Print the data returned by Timer::get_accumulated_wall_time_data() to the
* given stream.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print_accumulated_wall_time_data(StreamType &stream) const;
-template <class StreamType>
+template <typename StreamType>
inline void
Timer::print_last_lap_wall_time_data(StreamType &stream) const
{
-template <class StreamType>
+template <typename StreamType>
inline void
Timer::print_accumulated_wall_time_data(StreamType &stream) const
{
/**
* Output operator that outputs the selected optimizer type.
*/
- template <class StreamType>
+ template <typename StreamType>
inline StreamType &
operator<<(StreamType &s, OptimizerType o)
{
* Output operator that outputs optimization flags as a set of or'd
* text values.
*/
- template <class StreamType>
+ template <typename StreamType>
inline StreamType &
operator<<(StreamType &s, OptimizationFlags o)
{
template <int dim, int spacedim>
class FECollection;
} // namespace hp
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
class InterGridMap;
template <int dim, int spacedim>
*
* @ingroup febase
*/
-template <class PolynomialType, int dim, int spacedim = dim>
+template <typename PolynomialType, int dim, int spacedim = dim>
class FE_DGVector : public FE_PolyTensor<dim, spacedim>
{
public:
// TODO:[GK] deg+1 is wrong here and should be fixed after FiniteElementData was
// cleaned up
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
FE_DGVector<PolynomialType, dim, spacedim>::FE_DGVector(const unsigned int deg,
MappingKind map)
: FE_PolyTensor<dim, spacedim>(
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
std::unique_ptr<FiniteElement<dim, spacedim>>
FE_DGVector<PolynomialType, dim, spacedim>::clone() const
{
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
std::string
FE_DGVector<PolynomialType, dim, spacedim>::get_name() const
{
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
std::vector<unsigned int>
FE_DGVector<PolynomialType, dim, spacedim>::get_dpo_vector(
const unsigned int deg)
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
bool
FE_DGVector<PolynomialType, dim, spacedim>::has_support_on_face(
const unsigned int,
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
std::size_t
FE_DGVector<PolynomialType, dim, spacedim>::memory_consumption() const
{
* is initialized with an hp::FECollection, an hp::QCollection, and possibly
* an hp::MappingCollection).
*/
- template <class CellIteratorType, class CellNeighborIteratorType>
+ template <typename CellIteratorType, typename CellNeighborIteratorType>
void
reinit(const CellIteratorType & cell,
const unsigned int face_no,
* is initialized with an hp::FECollection, an hp::QCollection, and possibly
* an hp::MappingCollection).
*/
- template <class CellIteratorType>
+ template <typename CellIteratorType>
void
reinit(const CellIteratorType &cell,
const unsigned int face_no,
template <int dim, int spacedim>
-template <class CellIteratorType, class CellNeighborIteratorType>
+template <typename CellIteratorType, typename CellNeighborIteratorType>
void
FEInterfaceValues<dim, spacedim>::reinit(
const CellIteratorType & cell,
template <int dim, int spacedim>
-template <class CellIteratorType>
+template <typename CellIteratorType>
void
FEInterfaceValues<dim, spacedim>::reinit(const CellIteratorType &cell,
const unsigned int face_no,
* which cannot be implemented by this class but are left for implementation
* in derived classes.
*/
-template <class PolynomialType,
+template <typename PolynomialType,
int dim = PolynomialType::dimension + 1,
int spacedim = dim>
class FE_PolyFace : public FiniteElement<dim, spacedim>
DEAL_II_NAMESPACE_OPEN
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
FE_PolyFace<PolynomialType, dim, spacedim>::FE_PolyFace(
const PolynomialType & poly_space,
const FiniteElementData<dim> &fe_data,
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
unsigned int
FE_PolyFace<PolynomialType, dim, spacedim>::get_degree() const
{
//---------------------------------------------------------------------------
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
UpdateFlags
FE_PolyFace<PolynomialType, dim, spacedim>::requires_update_flags(
const UpdateFlags flags) const
//---------------------------------------------------------------------------
// Fill data of FEValues
//---------------------------------------------------------------------------
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
void
FE_PolyFace<PolynomialType, dim, spacedim>::fill_fe_values(
const typename Triangulation<dim, spacedim>::cell_iterator &,
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
void
FE_PolyFace<PolynomialType, dim, spacedim>::fill_fe_face_values(
const typename Triangulation<dim, spacedim>::cell_iterator &,
}
-template <class PolynomialType, int dim, int spacedim>
+template <typename PolynomialType, int dim, int spacedim>
void
FE_PolyFace<PolynomialType, dim, spacedim>::fill_fe_subface_values(
const typename Triangulation<dim, spacedim>::cell_iterator &,
*
* @ref UpdateFlags
*/
-template <class StreamType>
+template <typename StreamType>
inline StreamType &
operator<<(StreamType &s, const UpdateFlags u)
{
* A class whose specialization is used to define what type the curl of a
* vector valued function corresponds to.
*/
- template <int dim, class NumberType = double>
+ template <int dim, typename NumberType = double>
struct CurlType;
/**
*
* In 1d, the curl is a scalar.
*/
- template <class NumberType>
+ template <typename NumberType>
struct CurlType<1, NumberType>
{
using type = Tensor<1, 1, NumberType>;
*
* In 2d, the curl is a scalar.
*/
- template <class NumberType>
+ template <typename NumberType>
struct CurlType<2, NumberType>
{
using type = Tensor<1, 1, NumberType>;
*
* In 3d, the curl is a vector.
*/
- template <class NumberType>
+ template <typename NumberType>
struct CurlType<3, NumberType>
{
using type = Tensor<1, 3, NumberType>;
namespace internal
{
- template <int dim, int spacedim, class MeshType>
+ template <int dim, int spacedim, typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
class ActiveCellIterator
{
* @dealiiConceptRequires{
* concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES((concepts::is_triangulation_or_dof_handler<MeshType>))
#ifndef _MSC_VER
std::vector<typename MeshType::active_cell_iterator>
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<typename MeshType::active_cell_iterator> get_active_child_cells(
const typename MeshType::cell_iterator &cell);
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void get_active_neighbors(
const typename MeshType::active_cell_iterator & cell,
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::active_cell_iterator> compute_active_cell_halo_layer(
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::cell_iterator> compute_cell_halo_layer_on_level(
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<
typename MeshType::
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::active_cell_iterator> compute_active_cell_layer_within_distance(
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::active_cell_iterator> compute_ghost_cell_layer_within_distance(
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::pair<
Point<MeshType::space_dimension>,
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<BoundingBox<MeshType::space_dimension>> compute_mesh_predicate_bounding_box(
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<typename MeshType::active_cell_iterator> get_patch_around_cell(
const typename MeshType::active_cell_iterator &cell);
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<typename MeshType::active_cell_iterator> get_active_child_cells(
const typename MeshType::cell_iterator &cell)
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void get_active_neighbors(
const typename MeshType::active_cell_iterator & cell,
*
* @ref CacheUpdateFlags
*/
- template <class StreamType>
+ template <typename StreamType>
inline StreamType &
operator<<(StreamType &s, const CacheUpdateFlags u)
{
*
* @dealiiConceptRequires{concepts::is_triangulation_or_dof_handler<MeshType>}
*/
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
class InterGridMap : public Subscriptor
{
* Print the iterator to a stream <code>out</code>. The format is
* <tt>level.index</tt>.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print(StreamType &out) const;
template <typename Accessor>
-template <class StreamType>
+template <typename StreamType>
inline void
TriaRawIterator<Accessor>::print(StreamType &out) const
{
*
* @ingroup hp
*/
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
class FEValuesBase : public Subscriptor
{
public:
namespace hp
{
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
inline const FEValuesType &
FEValuesBase<dim, q_dim, FEValuesType>::get_present_fe_values() const
{
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
inline const FECollection<dim, FEValuesType::space_dimension> &
FEValuesBase<dim, q_dim, FEValuesType>::get_fe_collection() const
{
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
inline const MappingCollection<dim, FEValuesType::space_dimension> &
FEValuesBase<dim, q_dim, FEValuesType>::get_mapping_collection() const
{
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
inline const QCollection<q_dim> &
FEValuesBase<dim, q_dim, FEValuesType>::get_quadrature_collection() const
{
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
inline UpdateFlags
FEValuesBase<dim, q_dim, FEValuesType>::get_update_flags() const
{
// able to use functions like vector.block(1)(block_local_id), instead of
// vector(global_id). This avoids transforming indices one-by-one later
// on.
- template <typename number, class BlockType>
+ template <typename number, typename BlockType>
inline void
make_block_starts(const BlockType & block_object,
GlobalRowsFromLocal<number> &global_rows,
// same as before, but for std::vector<uint> instead of
// GlobalRowsFromLocal. Used in functions for sparsity patterns.
- template <class BlockType>
+ template <typename BlockType>
inline void
make_block_starts(const BlockType & block_object,
std::vector<size_type> &row_indices,
* existing row lengths and allocated row lengths. Otherwise, just the
* relation of allocated and used entries is shown.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print_statistics(StreamType &s, bool full = false);
template <typename number>
-template <class StreamType>
+template <typename StreamType>
inline void
BlockSparseMatrixEZ<number>::print_statistics(StreamType &out, bool full)
{
* quadratic matrices are printed first in their row. If it is false,
* the elements in a row are written in ascending column order.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print(StreamType &out,
const bool across = false,
template <typename Number>
- template <class StreamType>
+ template <typename StreamType>
inline void
SparseMatrix<Number>::print(StreamType &out,
const bool across,
* stream before setting these given values for output, and restores the
* previous values after output.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print(StreamType & s,
const unsigned int width = 5,
template <typename number>
-template <class StreamType>
+template <typename StreamType>
inline void
FullMatrix<number>::print(StreamType & s,
const unsigned int w,
* R(x_k,b)$. The matrix <i>A</i> itself is only used to compute the
* residual.
*/
- template <typename MatrixType, class RelaxationType>
+ template <typename MatrixType, typename RelaxationType>
void
solve(const MatrixType & A,
VectorType & x,
template <typename VectorType>
-template <typename MatrixType, class RelaxationType>
+template <typename MatrixType, typename RelaxationType>
void
SolverRelaxation<VectorType>::solve(const MatrixType & A,
VectorType & x,
* internal storage scheme. If it is false, the elements in a row are
* written in ascending column order.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print(StreamType &out,
const bool across = false,
template <typename number>
-template <class StreamType>
+template <typename StreamType>
inline void
SparseMatrix<number>::print(StreamType &out,
const bool across,
* existing row lengths and allocated row lengths. Otherwise, just the
* relation of allocated and used entries is shown.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print_statistics(StreamType &s, bool full = false);
template <typename number>
-template <class StreamType>
+template <typename StreamType>
inline void
SparseMatrixEZ<number>::print_statistics(StreamType &out, bool full)
{
* operators/preconditioners. For details, see
* https://docs.trilinos.org/latest-release/packages/belos/doc/html/classBelos_1_1Operator.html.
*/
- template <class OperatorType, typename VectorType>
+ template <typename OperatorType, typename VectorType>
class OperatorWrapper
: public Belos::Operator<typename VectorType::value_type>
{
*
* @ref AssembleFlags
*/
- template <class StreamType>
+ template <typename StreamType>
inline StreamType &
operator<<(StreamType &s, AssembleFlags u)
{
void
reinit(const BlockIndices &local_sizes);
- template <class StreamType>
+ template <typename StreamType>
void
print_debug(StreamType &os) const;
template <typename number>
- template <class StreamType>
+ template <typename StreamType>
void
LocalResults<number>::print_debug(StreamType &os) const
{
* A helper class to provide a type definition for the underlying cell
* iterator type.
*/
- template <class CellIteratorType>
+ template <typename CellIteratorType>
struct CellIteratorBaseType
{
/**
* This specialization is for IteratorRange, which may have either a
* TriaActiveIterator or a FilteredIterator as its base type.
*/
- template <class CellIteratorType>
+ template <typename CellIteratorType>
struct CellIteratorBaseType<IteratorOverIterators<CellIteratorType>>
{
/**
* TriaActiveIterator as its base type, or may be nested with another
* FilteredIterator as the type to iterate over.
*/
- template <class CellIteratorType>
+ template <typename CellIteratorType>
struct CellIteratorBaseType<FilteredIterator<CellIteratorType>>
{
/**
*
* @ingroup MeshWorker
*/
- template <class CellIteratorType,
+ template <typename CellIteratorType,
class ScratchData,
class CopyData,
- class CellIteratorBaseType =
+ typename CellIteratorBaseType =
typename internal::CellIteratorBaseType<CellIteratorType>::type>
void
mesh_loop(
*
* @ingroup MeshWorker
*/
- template <class CellIteratorType,
+ template <typename CellIteratorType,
class ScratchData,
class CopyData,
- class CellIteratorBaseType =
+ typename CellIteratorBaseType =
typename internal::CellIteratorBaseType<CellIteratorType>::type>
void
mesh_loop(
*
* @ingroup MeshWorker
*/
- template <class CellIteratorType,
+ template <typename CellIteratorType,
class ScratchData,
class CopyData,
class MainClass>
*
* @ingroup MeshWorker
*/
- template <class CellIteratorType,
+ template <typename CellIteratorType,
class ScratchData,
class CopyData,
class MainClass,
- class CellIteratorBaseType =
+ typename CellIteratorBaseType =
typename internal::CellIteratorBaseType<CellIteratorType>::type>
void
mesh_loop(IteratorRange<CellIteratorType> iterator_range,
/**
* Print the contents of the selection to the stream.
*/
- template <class StreamType, typename DATA>
+ template <typename StreamType, typename DATA>
void
print(StreamType &s, const AnyData &v) const;
/**
* Print the number of selections to the stream.
*/
- template <class StreamType>
+ template <typename StreamType>
void
print(StreamType &s) const;
}
- template <class StreamType>
+ template <typename StreamType>
inline void
VectorSelector::print(StreamType &s) const
{
}
- template <class StreamType, typename DATA>
+ template <typename StreamType, typename DATA>
inline void
VectorSelector::print(StreamType &s, const AnyData &v) const
{
* smoother object. Therefore, the smoother object for each level must be
* constructed by hand.
*/
-template <typename MatrixType, class RelaxationType, typename number>
+template <typename MatrixType, typename RelaxationType, typename number>
class MGSmootherBlock : public MGSmoother<BlockVector<number>>
{
public:
* This function stores pointers to the level matrices and smoothing
* operator for each level.
*/
- template <class MGMatrixType, class MGRelaxationType>
+ template <typename MGMatrixType, typename MGRelaxationType>
void
initialize(const MGMatrixType &matrices, const MGRelaxationType &smoothers);
#ifndef DOXYGEN
-template <typename MatrixType, class RelaxationType, typename number>
+template <typename MatrixType, typename RelaxationType, typename number>
inline MGSmootherBlock<MatrixType, RelaxationType, number>::MGSmootherBlock(
const unsigned int steps,
const bool variable,
{}
-template <typename MatrixType, class RelaxationType, typename number>
+template <typename MatrixType, typename RelaxationType, typename number>
inline void
MGSmootherBlock<MatrixType, RelaxationType, number>::clear()
{
}
-template <typename MatrixType, class RelaxationType, typename number>
-template <class MGMatrixType, class MGRelaxationType>
+template <typename MatrixType, typename RelaxationType, typename number>
+template <typename MGMatrixType, typename MGRelaxationType>
inline void
MGSmootherBlock<MatrixType, RelaxationType, number>::initialize(
const MGMatrixType & m,
}
-template <typename MatrixType, class RelaxationType, typename number>
+template <typename MatrixType, typename RelaxationType, typename number>
inline void
MGSmootherBlock<MatrixType, RelaxationType, number>::set_reverse(
const bool flag)
}
-template <typename MatrixType, class RelaxationType, typename number>
+template <typename MatrixType, typename RelaxationType, typename number>
inline std::size_t
MGSmootherBlock<MatrixType, RelaxationType, number>::memory_consumption() const
{
}
-template <typename MatrixType, class RelaxationType, typename number>
+template <typename MatrixType, typename RelaxationType, typename number>
inline void
MGSmootherBlock<MatrixType, RelaxationType, number>::smooth(
const unsigned int level,
* the multigrid method must be used only with the vector associated to that
* single block.
*/
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
class SmootherRelaxation : public MGLevelObject<RelaxationType>,
public MGSmoother<VectorType>
{
* float and @p double. Additional instantiations may be created by including
* the file mg_smoother.templates.h.
*/
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
class MGSmootherRelaxation : public MGSmoother<VectorType>
{
public:
namespace mg
{
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
inline SmootherRelaxation<RelaxationType, VectorType>::SmootherRelaxation(
const unsigned int steps,
const bool variable,
{}
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
inline void
SmootherRelaxation<RelaxationType, VectorType>::clear()
{
}
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
template <typename MatrixType2>
inline void
SmootherRelaxation<RelaxationType, VectorType>::initialize(
}
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
template <typename MatrixType2, class DATA>
inline void
SmootherRelaxation<RelaxationType, VectorType>::initialize(
}
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
inline void
SmootherRelaxation<RelaxationType, VectorType>::smooth(
const unsigned int level,
}
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
inline void
SmootherRelaxation<RelaxationType, VectorType>::apply(
const unsigned int level,
}
- template <class RelaxationType, typename VectorType>
+ template <typename RelaxationType, typename VectorType>
inline std::size_t
SmootherRelaxation<RelaxationType, VectorType>::memory_consumption() const
{
//----------------------------------------------------------------------//
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
inline MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::
MGSmootherRelaxation(const unsigned int steps,
const bool variable,
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::clear()
{
}
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
template <typename MatrixType2>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
}
}
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
template <typename MatrixType2, class DATA>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
}
}
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
template <typename MatrixType2, class DATA>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
}
}
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
template <typename MatrixType2, class DATA>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::initialize(
}
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::smooth(
const unsigned int level,
}
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
inline void
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::apply(
const unsigned int level,
-template <typename MatrixType, class RelaxationType, typename VectorType>
+template <typename MatrixType, typename RelaxationType, typename VectorType>
inline std::size_t
MGSmootherRelaxation<MatrixType, RelaxationType, VectorType>::
memory_consumption() const
*/
SmartPointer<const MGMatrixBase<VectorType>, Multigrid<VectorType>> edge_up;
- template <int dim, class OtherVectorType, class TRANSFER>
+ template <int dim, typename OtherVectorType, class TRANSFER>
friend class PreconditionMG;
};
*
* This is the operator used by LAC iterative solvers.
*/
- template <class OtherVectorType>
+ template <typename OtherVectorType>
void
vmult(OtherVectorType &dst, const OtherVectorType &src) const;
* Preconditioning operator. Calls the @p vcycle function of the @p MG
* object passed to the constructor.
*/
- template <class OtherVectorType>
+ template <typename OtherVectorType>
void
vmult_add(OtherVectorType &dst, const OtherVectorType &src) const;
*
* Not implemented, but the definition may be needed.
*/
- template <class OtherVectorType>
+ template <typename OtherVectorType>
void
Tvmult(OtherVectorType &dst, const OtherVectorType &src) const;
*
* Not implemented, but the definition may be needed.
*/
- template <class OtherVectorType>
+ template <typename OtherVectorType>
void
Tvmult_add(OtherVectorType &dst, const OtherVectorType &src) const;
}
template <int dim, typename VectorType, class TRANSFER>
-template <class OtherVectorType>
+template <typename OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::vmult(
OtherVectorType & dst,
template <int dim, typename VectorType, class TRANSFER>
-template <class OtherVectorType>
+template <typename OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::vmult_add(
OtherVectorType & dst,
template <int dim, typename VectorType, class TRANSFER>
-template <class OtherVectorType>
+template <typename OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::Tvmult(OtherVectorType &,
const OtherVectorType &) const
template <int dim, typename VectorType, class TRANSFER>
-template <class OtherVectorType>
+template <typename OtherVectorType>
void
PreconditionMG<dim, VectorType, TRANSFER>::Tvmult_add(
OtherVectorType &,
* implemented, the passed values of these must equal
* numbers::invalid_unsigned_int.
*/
- template <class CellIteratorType, class CellNeighborIteratorType>
+ template <typename CellIteratorType, typename CellNeighborIteratorType>
void
reinit(const CellIteratorType & cell,
const unsigned int face_no,
* FEInterfaceValues object can be retrieved for each region using the
* functions get_inside_fe_values() or get_outside_fe_values().
*/
- template <class CellIteratorType>
+ template <typename CellIteratorType>
void
reinit(const CellIteratorType &cell, const unsigned int face_no);
/*---------------------- Inline functions ---------------------*/
template <int dim>
- template <class CellIteratorType>
+ template <typename CellIteratorType>
inline void
FEInterfaceValues<dim>::reinit(const CellIteratorType &cell,
const unsigned int face_no)
template <int dim>
- template <class CellIteratorType, class CellNeighborIteratorType>
+ template <typename CellIteratorType, typename CellNeighborIteratorType>
inline void
FEInterfaceValues<dim>::reinit(const CellIteratorType & cell,
const unsigned int face_no,
class FullMatrix;
template <int dim, typename Number>
class Function;
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
class InterGridMap;
template <int dim, int spacedim>
}
- template <int dim, int spacedim, class StreamType>
+ template <int dim, int spacedim, typename StreamType>
void
write_data(const std::vector<Patch<dim, spacedim>> &patches,
unsigned int n_data_sets,
// cell, renumbers DoF indices on it. The function starts renumbering with
// 'next_free_dof_index' and returns the first still unused DoF index at the
// end of its operation.
- template <int dim, class CellIteratorType>
+ template <int dim, typename CellIteratorType>
types::global_dof_index
compute_hierarchical_recursive(
const types::global_dof_index next_free_dof_offset,
* checking if the smallest BoundingBox that encloses the cell has the same
* vertices as the cell itself.
*/
-template <class CellType>
+template <typename CellType>
bool
is_cartesian(const CellType &cell)
{
/**
* Store the data about the given face @p face.
*/
- template <class FaceIteratorType>
+ template <typename FaceIteratorType>
void
insert_face_data(const FaceIteratorType &face)
{
class FaceDataHelper<1>
{
public:
- template <class FaceIteratorType>
+ template <typename FaceIteratorType>
void
insert_face_data(const FaceIteratorType &)
{}
{
namespace BoundingBoxPredicate
{
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(
concepts::is_triangulation_or_dof_handler<MeshType>)
std::tuple<
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<BoundingBox<MeshType::space_dimension>> compute_mesh_predicate_bounding_box(
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES((concepts::is_triangulation_or_dof_handler<MeshType>))
#ifndef _MSC_VER
std::vector<typename MeshType::active_cell_iterator>
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::active_cell_iterator> compute_active_cell_halo_layer(
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::cell_iterator> compute_cell_halo_layer_on_level(
namespace
{
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
bool contains_locally_owned_cells(
const std::vector<typename MeshType::active_cell_iterator> &cells)
return false;
}
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
bool contains_artificial_cells(
const std::vector<typename MeshType::active_cell_iterator> &cells)
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<
typename MeshType::
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::
vector<typename MeshType::active_cell_iterator> compute_active_cell_layer_within_distance(
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<
typename MeshType::
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::pair<
Point<MeshType::space_dimension>,
}
- template <class MeshType>
+ template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::vector<typename MeshType::active_cell_iterator> get_patch_around_cell(
const typename MeshType::active_cell_iterator &cell)
DEAL_II_NAMESPACE_OPEN
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
InterGridMap<MeshType>::InterGridMap()
: source_grid(nullptr, typeid(*this).name())
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void InterGridMap<MeshType>::make_mapping(const MeshType &source_grid,
const MeshType &destination_grid)
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void InterGridMap<MeshType>::set_mapping(const cell_iterator &src_cell,
const cell_iterator &dst_cell)
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void InterGridMap<MeshType>::set_entries_to_cell(const cell_iterator &src_cell,
const cell_iterator &dst_cell)
}
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
typename InterGridMap<MeshType>::cell_iterator
InterGridMap<MeshType>::operator[](const cell_iterator &source_cell) const
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
void InterGridMap<MeshType>::clear()
{
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
const MeshType &InterGridMap<MeshType>::get_source_grid() const
{
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
const MeshType &InterGridMap<MeshType>::get_destination_grid() const
{
-template <class MeshType>
+template <typename MeshType>
DEAL_II_CXX20_REQUIRES(concepts::is_triangulation_or_dof_handler<MeshType>)
std::size_t InterGridMap<MeshType>::memory_consumption() const
{
// -------------------------- FEValuesBase -------------------------
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const MappingCollection<dim, FEValuesType::space_dimension>
& mapping_collection,
, update_flags(update_flags)
{}
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const MappingCollection<dim, FEValuesType::space_dimension>
& mapping_collection,
{}
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
const QCollection<q_dim> & q_collection,
{}
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const FECollection<dim, FEValuesType::space_dimension> &fe_collection,
const std::vector<QCollection<q_dim>> & q_collection,
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
FEValuesBase<dim, q_dim, FEValuesType>::FEValuesBase(
const FEValuesBase<dim, q_dim, FEValuesType> &other)
: Subscriptor(other)
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
FEValuesType &
FEValuesBase<dim, q_dim, FEValuesType>::select_fe_values(
const unsigned int fe_index,
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
void
FEValuesBase<dim, q_dim, FEValuesType>::precalculate_fe_values(
const std::vector<unsigned int> &fe_indices,
- template <int dim, int q_dim, class FEValuesType>
+ template <int dim, int q_dim, typename FEValuesType>
void
FEValuesBase<dim, q_dim, FEValuesType>::precalculate_fe_values()
{
DEAL_II_NAMESPACE_OPEN
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
BlockSparsityPatternBase<SparsityPatternType>::BlockSparsityPatternBase()
: block_rows(0)
, block_columns(0)
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
BlockSparsityPatternBase<SparsityPatternType>::BlockSparsityPatternBase(
const size_type block_rows,
const size_type block_columns)
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
BlockSparsityPatternBase<SparsityPatternType>::BlockSparsityPatternBase(
const BlockSparsityPatternBase &s)
: BlockSparsityPatternBase()
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::reinit(
const size_type new_block_rows,
}
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
BlockSparsityPatternBase<SparsityPatternType> &
BlockSparsityPatternBase<SparsityPatternType>::operator=(
const BlockSparsityPatternBase<SparsityPatternType> &bsp)
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
typename BlockSparsityPatternBase<SparsityPatternType>::size_type
BlockSparsityPatternBase<SparsityPatternType>::compute_n_rows() const
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
typename BlockSparsityPatternBase<SparsityPatternType>::size_type
BlockSparsityPatternBase<SparsityPatternType>::compute_n_cols() const
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::collect_sizes()
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::compress()
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
bool
BlockSparsityPatternBase<SparsityPatternType>::empty() const
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
typename BlockSparsityPatternBase<SparsityPatternType>::size_type
BlockSparsityPatternBase<SparsityPatternType>::max_entries_per_row() const
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
typename BlockSparsityPatternBase<SparsityPatternType>::size_type
BlockSparsityPatternBase<SparsityPatternType>::n_nonzero_elements() const
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::print(std::ostream &out) const
{
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::print_gnuplot(
std::ostream &out) const
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
void
BlockSparsityPatternBase<SparsityPatternType>::print_svg(
std::ostream &out) const
-template <class SparsityPatternType>
+template <typename SparsityPatternType>
std::size_t
BlockSparsityPatternBase<SparsityPatternType>::memory_consumption() const
{