template <typename VectorType>
ExplicitRungeKutta<VectorType>::ExplicitRungeKutta(const runge_kutta_method method)
{
- initialize(method);
+ ExplicitRungeKutta<VectorType>::initialize(method);
}
max_it(max_it),
tolerance(tolerance)
{
- initialize(method);
+ ImplicitRungeKutta<VectorType>::initialize(method);
}
last_same_as_first(false),
last_stage(nullptr)
{
- initialize(method);
+ EmbeddedExplicitRungeKutta<VectorType>::initialize(method);
}
BlockSparseMatrix<number>::
BlockSparseMatrix (const BlockSparsityPattern &sparsity)
{
- reinit (sparsity);
+ BlockSparseMatrix<number>::reinit (sparsity);
}
val(nullptr),
max_len(0)
{
- reinit (c);
+ ChunkSparseMatrix<number>::reinit (c);
}
Assert (c.n_rows() == id.m(), ExcDimensionMismatch (c.n_rows(), id.m()));
Assert (c.n_cols() == id.n(), ExcDimensionMismatch (c.n_cols(), id.n()));
- reinit (c);
+ ChunkSparseMatrix<number>::reinit (c);
for (size_type i=0; i<n(); ++i)
this->set(i,i,1.);
}
:
val(nullptr)
{
- reinit(0, true);
+ ReadWriteVector<Number>::reinit(0, true);
}
:
val(nullptr)
{
- reinit (size, false);
+ ReadWriteVector<Number>::reinit (size, false);
}
:
val(nullptr)
{
- reinit (locally_stored_indices);
+ ReadWriteVector<Number>::reinit (locally_stored_indices);
}
template <typename number>
SparseLUDecomposition<number>::~SparseLUDecomposition()
{
- clear();
+ SparseLUDecomposition<number>::clear();
}
val(nullptr),
max_len(0)
{
- reinit (c);
+ SparseMatrix<number>::reinit (c);
}
Assert (c.n_rows() == id.m(), ExcDimensionMismatch (c.n_rows(), id.m()));
Assert (c.n_cols() == id.n(), ExcDimensionMismatch (c.n_cols(), id.n()));
- reinit (c);
+ SparseMatrix<number>::reinit (c);
for (size_type i=0; i<n(); ++i)
this->set(i,i,1.);
}
template <typename number>
SparseMIC<number>::~SparseMIC()
{
- clear();
+ SparseMIC<number>::clear();
}
max_vec_size(0),
values(nullptr, &free)
{
- reinit(0);
+ Vector<Number>::reinit(0);
}
max_vec_size(0),
values(nullptr, &free)
{
- reinit (n, false);
+ Vector<Number>::reinit (n, false);
}
template <typename DoFHandlerType, int patch_dim, int patch_space_dim>
DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::~DataOut_DoFData ()
{
- clear ();
+ DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::clear ();
}
template <int dim, int spacedim>
Triangulation<dim,spacedim>::~Triangulation ()
{
- clear ();
+ Triangulation<dim, spacedim>::clear ();
Assert (triangulation_has_content == false,
ExcInternalError());
DoFHandler<dim,spacedim>::~DoFHandler ()
{
// release allocated memory
- clear ();
+ DoFHandler<dim, spacedim>::clear ();
// also release the policy. this needs to happen before the
// current object disappears because the policy objects
tria_listeners.clear ();
// ...and release allocated memory
- clear ();
+ DoFHandler<dim, spacedim>::clear ();
}
Vector::Vector ()
: communicator (MPI_COMM_SELF)
{
- create_vector(0, 0);
+ Vector::create_vector(0, 0);
}
const IndexSet &read_write_vector_index_set,
const MPI_Comm &communicator)
{
- reinit(vector_space_vector_index_set, read_write_vector_index_set, communicator);
+ CommunicationPattern::reinit(vector_space_vector_index_set, read_write_vector_index_set, communicator);
}