/**
* The virtual destructor.
*/
- ~OperatorBase();
+ virtual ~OperatorBase() = default;
/**
* The actual operation, which is implemented in a derived class.
template <typename VectorType>
class OutputOperator : public Subscriptor
{
- OutputOperator(const OutputOperator<VectorType> &) = delete;
public:
+ /**
+ * Constructor initializing member variables with invalid data.
+ */
OutputOperator ();
+
+ /**
+ * The copy constructor is deleted since objects of this class
+ * should not be copied.
+ */
+ OutputOperator(const OutputOperator<VectorType> &) = delete;
+
/**
* Empty virtual destructor.
*/
- virtual ~OutputOperator();
+ virtual ~OutputOperator() = default;
/**
* Set the stream @p os to which data is written. If no stream is selected
namespace Algorithms
{
- template <typename VectorType>
- OutputOperator<VectorType>::~OutputOperator() = default;
-
template <typename VectorType>
OutputOperator<VectorType>::OutputOperator()
:
/**
* Virtual destructor; absolutely necessary in this case.
*/
- virtual ~AutoDerivativeFunction ();
+ virtual ~AutoDerivativeFunction () = default;
/**
* Choose the difference formula. See the enum #DifferenceFormula for
/**
* Constructor.
*/
- ConvergenceTable();
+ ConvergenceTable() = default;
/**
* Rate in relation to the rows.
* Destructor. Does nothing, but is declared virtual since this class has
* virtual functions.
*/
- virtual ~DataOutInterface ();
+ virtual ~DataOutInterface () = default;
/**
* Obtain data through get_patches() and write it to <tt>out</tt> in OpenDX
/**
* Virtual destructor.
*/
- virtual ~FlowFunction();
+ virtual ~FlowFunction() = default;
/**
* Store an adjustment for the pressure function, such that its mean value
*/
PoisseuilleFlow<dim> (const double r,
const double Re);
- virtual ~PoisseuilleFlow();
+
+ virtual ~PoisseuilleFlow() = default;
virtual void vector_values (const std::vector<Point<dim> > &points,
std::vector<std::vector<double> > &values) const;
* Change the viscosity and the reaction parameter.
*/
void set_parameters (const double viscosity, const double reaction);
- virtual ~StokesCosine();
+
+ virtual ~StokesCosine() = default;
virtual void vector_values (const std::vector<Point<dim> > &points,
std::vector<std::vector<double> > &values) const;
* Stokes problem.
*/
Kovasznay (const double Re, bool Stokes = false);
- virtual ~Kovasznay();
+
+ virtual ~Kovasznay() = default;
virtual void vector_values (const std::vector<Point<2> > &points,
std::vector<std::vector<double> > &values) const;
* This destructor is defined as virtual so as to coincide with all other
* aspects of class.
*/
- virtual ~VectorFunctionFromTensorFunction();
+ virtual ~VectorFunctionFromTensorFunction() = default;
/**
* Return a single component of a vector-valued function at a given point.
}
+
+// The destructor is pure virtual so we can't default it
+// in the declaration.
template <int dim, typename Number>
Function<dim, Number>::~Function () = default;
}
-template <int dim, typename Number>
-VectorFunctionFromTensorFunction<dim, Number>::~VectorFunctionFromTensorFunction () = default;
-
template <int dim, typename Number>
inline
/**
* Virtual destructor.
*/
- virtual ~FunctionTime();
+ virtual ~FunctionTime() = default;
/**
* Return the value of the time variable.
-template <typename Number>
-FunctionTime<Number>::~FunctionTime() = default;
-
-
-
template <typename Number>
void
FunctionTime<Number>::set_time (const Number new_time)
* safer as we have virtual functions. It actually does nothing
* spectacular.
*/
- virtual ~ParameterHandler ();
+ virtual ~ParameterHandler () = default;
/**
* Parse each line from a stream until the stream returns the <tt>eof</tt>
* Destructor. It doesn't actually do anything, but is declared to force
* derived classes to have a virtual destructor.
*/
- virtual ~UserClass ();
+ virtual ~UserClass () = default;
/**
* <tt>create_new</tt> must provide a clean object, either by creating a
* Destructor. Declare this only to have a virtual destructor, which is
* safer as we have virtual functions. It actually does nothing spectacular.
*/
- virtual ~MultipleParameterLoop ();
+ virtual ~MultipleParameterLoop () = default;
/**
* Read input from a stream until the stream returns the <tt>eof</tt>
/**
* Make destructor of this and all derived classes virtual.
*/
- virtual ~PatternBase ();
+ virtual ~PatternBase () = default;
/**
* Return <tt>true</tt> if the given string matches the pattern.
* Constructor. (Allow for at least one non-virtual function in this
* class, as otherwise sometimes no virtual table is emitted.)
*/
- Anything ();
+ Anything () = default;
/**
* Return <tt>true</tt> if the string matches its constraints, i.e.
/**
* Constructor.
*/
- DirectoryName ();
+ DirectoryName () = default;
/**
* Return <tt>true</tt> if the string matches its constraints, i.e.
/**
* Default constructor.
*/
- TableEntry ();
+ TableEntry () = default;
/**
* Constructor. Initialize this table element with the value
* usually not used by their true type, but rather through pointers to this
* base class.
*/
- virtual ~TensorFunction ();
+ virtual ~TensorFunction () = default;
/**
* Return the value of the function at the given point.
ConstantTensorFunction (const dealii::Tensor<rank, dim, Number> &value,
const Number initial_time = 0.0);
- virtual ~ConstantTensorFunction ();
+ virtual ~ConstantTensorFunction () = default;
virtual typename dealii::TensorFunction<rank, dim, Number>::value_type value (const Point<dim> &p) const;
{}
-template <int rank, int dim, typename Number>
-TensorFunction<rank, dim, Number>::~TensorFunction () = default;
-
template <int rank, int dim, typename Number>
typename TensorFunction<rank, dim, Number>::value_type
{}
-template <int rank, int dim, typename Number>
-ConstantTensorFunction<rank, dim, Number>::~ConstantTensorFunction () = default;
-
template <int rank, int dim, typename Number>
typename TensorFunction<rank, dim, Number>::value_type
* Default constructor. Initialize each thread local object using its
* default constructor.
*/
- ThreadLocalStorage ();
+ ThreadLocalStorage () = default;
/**
* A kind of copy constructor. Initialize each thread local object by
// ----------------- inline and template functions ----------------------------
- template <typename T>
- inline
- ThreadLocalStorage<T>::ThreadLocalStorage() = default;
-
-
template <typename T>
inline
ThreadLocalStorage<T>::ThreadLocalStorage(const T &t)
/**
* Destructor.
*/
- virtual ~Triangulation ();
+ virtual ~Triangulation () = default;
/**
* Coarsen and refine the mesh according to refinement and coarsening
/**
* Destructor.
*/
- ~SolutionTransfer();
+ ~SolutionTransfer() = default;
/**
* Prepares the @p SolutionTransfer for coarsening and refinement. It
/**
* Destructor. Made virtual to allow polymorphism.
*/
- virtual ~InternalDataBase ();
+ virtual ~InternalDataBase () = default;
/**
* A set of update flags specifying the kind of information that an
/**
* Destructor.
*/
- virtual ~FE_P1NC ();
+ virtual ~FE_P1NC () = default;
/**
* Virtual destructor doing nothing but making the compiler happy.
*/
- virtual ~FEFactoryBase();
+ virtual ~FEFactoryBase() = default;
};
/**
namespace FETools
{
- template <int dim, int spacedim>
- FEFactoryBase<dim,spacedim>::~FEFactoryBase() = default;
-
-
-
template <int dim, int spacedim>
void compute_component_wise(
const FiniteElement<dim,spacedim> &element,
/**
* Virtual destructor.
*/
- virtual ~Mapping ();
+ virtual ~Mapping () = default;
/**
* Return a pointer to a copy of the present object. The caller of this copy
*/
class InternalDataBase
{
- private:
- /**
- * Copy construction is forbidden.
- */
- InternalDataBase (const InternalDataBase &) = delete;
-
public:
/**
* Constructor. Sets update_flags to @p update_default and @p first_cell
*/
InternalDataBase ();
+ /**
+ * Copy construction is forbidden.
+ */
+ InternalDataBase (const InternalDataBase &) = delete;
+
/**
* Virtual destructor for derived classes
*/
- virtual ~InternalDataBase ();
+ virtual ~InternalDataBase () = default;
/**
* A set of update flags specifying the kind of information that an
/**
* Constructor.
*/
- MappingManifold ();
+ MappingManifold () = default;
/**
* Copy constructor.
/**
* Constructor.
*/
- InternalData();
+ InternalData() = default;
/**
* Initialize the object's member variables related to cell data based on
* Destructor. Does nothing here, but needs to be declared virtual to make
* class hierarchies derived from this class possible.
*/
- virtual ~Manifold ();
+ virtual ~Manifold () = default;
/**
* @name Computing the location of points.
* Destructor. Does nothing here, but needs to be declared to make it
* virtual.
*/
- virtual ~ChartManifold ();
+ virtual ~ChartManifold () = default;
/**
* Refer to the general documentation of this class and the documentation of
/**
* Destructor.
*/
- virtual ~PersistentTriangulation ();
+ virtual ~PersistentTriangulation () = default;
/**
* Overloaded version of the same function in the base class which stores
* Destructor. Does nothing here, but needs to be declared to make it
* virtual.
*/
- virtual ~Boundary ();
+ virtual ~Boundary () = default;
/**
/**
* Default constructor. Some compilers require this for some reasons.
*/
- StraightBoundary ();
+ StraightBoundary () = default;
/**
* Let the new point be the arithmetic mean of the two vertices of the line.
* Default constructor. Leads to an empty collection that can later be
* filled using push_back().
*/
- FECollection ();
+ FECollection () = default;
/**
* Conversion constructor. This constructor creates a FECollection from a
* Default constructor. Leads to an empty collection that can later be
* filled using push_back().
*/
- MappingCollection ();
+ MappingCollection () = default;
/**
* Conversion constructor. This constructor creates a MappingCollection
* useful if you want such objects as member variables in other classes. You
* can make the structure usable by calling the reinit() function.
*/
- BlockSparsityPattern ();
+ BlockSparsityPattern () = default;
/**
* Initialize the matrix with the given number of block rows and columns.
* useful if you want such objects as member variables in other classes. You
* can make the structure usable by calling the reinit() function.
*/
- BlockDynamicSparsityPattern ();
+ BlockDynamicSparsityPattern () = default;
/**
* Initialize the matrix with the given number of block rows and columns.
* useful if you want such objects as member variables in other classes.
* You can make the structure usable by calling the reinit() function.
*/
- BlockSparsityPattern ();
+ BlockSparsityPattern () = default;
/**
* Initialize the matrix with the given number of block rows and columns.
/**
* Destructor. Clears memory
*/
- ~BlockVector ();
+ ~BlockVector () = default;
/**
* Call the compress() function on all the subblocks.
-template <typename Number>
-BlockVector<Number>::~BlockVector () = default;
-
-
-
#ifdef DEAL_II_WITH_TRILINOS
template <typename Number>
inline
/**
* Destructor.
*/
- ~ChunkSparsityPattern ();
+ ~ChunkSparsityPattern () = default;
/**
* Copy operator. For this the same holds as for the copy constructor: it is
/**
* Create an empty object.
*/
- Householder ();
+ Householder () = default;
/**
* Create an object holding the QR-decomposition of a matrix.
// QR-transformation cf. Stoer 1 4.8.2 (p. 191)
-template <typename number>
-Householder<number>::Householder() = default;
-
-
-
template <typename number>
template <typename number2>
void
/**
* Destructor. Declared in order to make it virtual.
*/
- virtual ~MatrixOut ();
+ virtual ~MatrixOut () = default;
/**
* Generate a list of patches from the given matrix and use the given string
* reinit(BlockSparsityPattern). The number of blocks per row and column
* are then determined by that function.
*/
- BlockSparseMatrix ();
+ BlockSparseMatrix () = default;
/**
* Destructor.
*/
- ~BlockSparseMatrix ();
+ ~BlockSparseMatrix () = default;
/**
* Pseudo copy operator only copying empty objects. The sizes of the
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionJacobi ();
+ PreconditionJacobi () = default;
/**
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionBlockJacobi ();
+ PreconditionBlockJacobi () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionSOR ();
+ PreconditionSOR () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionSSOR ();
+ PreconditionSSOR () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionEisenstat ();
+ PreconditionEisenstat () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionICC ();
+ PreconditionICC () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionILU ();
+ PreconditionILU () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionLU ();
+ PreconditionLU () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionBoomerAMG ();
+ PreconditionBoomerAMG () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionParaSails ();
+ PreconditionParaSails () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
* Empty Constructor. You need to call initialize() before using this
* object.
*/
- PreconditionNone ();
+ PreconditionNone () = default;
/**
* Constructor. Take the matrix which is used to form the preconditioner,
/**
* Destructor.
*/
- virtual ~SolverBase ();
+ virtual ~SolverBase () = default;
/**
* Solve the linear system <tt>Ax=b</tt>. Depending on the information
{}
-template <typename number>
-PreconditionBlockBase<number>::~PreconditionBlockBase () = default;
-
template <typename MatrixType, typename inverse_type>
PreconditionBlock<MatrixType,inverse_type>::PreconditionBlock (bool store)
/**
* The virtual destructor
*/
- ~PreconditionBlockBase();
+ ~PreconditionBlockBase() = default;
/**
* Deletes the inverse diagonal block matrices if existent hence leaves the
* Virtual destructor is needed as there are virtual functions in this
* class.
*/
- virtual ~SolverControl();
+ virtual ~SolverControl() = default;
/**
* Interface to parameter file.
* Virtual destructor is needed as there are virtual functions in this
* class.
*/
- virtual ~ReductionControl();
+ virtual ~ReductionControl() = default;
/**
* Interface to parameter file.
* Virtual destructor is needed as there are virtual functions in this
* class.
*/
- virtual ~IterationNumberControl();
+ virtual ~IterationNumberControl() = default;
/**
* Decide about success or failure of an iteration. This function bases
* Virtual destructor is needed as there are virtual functions in this
* class.
*/
- virtual ~ConsecutiveControl();
+ virtual ~ConsecutiveControl() = default;
/**
* Decide about success or failure of an iteration, see the class description
/**
* Virtual destructor.
*/
- virtual ~SolverRichardson ();
+ virtual ~SolverRichardson () = default;
/**
* Solve the linear system $Ax=b$ for x.
-template <class VectorType>
-SolverRichardson<VectorType>::~SolverRichardson() = default;
-
-
template <class VectorType>
template <typename MatrixType, typename PreconditionerType>
void
* Call the @p initialize function before using this object as
* preconditioner.
*/
- SparseILU ();
+ SparseILU () = default;
/**
* Make SparseLUDecomposition::AdditionalData accessible to this class as
DEAL_II_NAMESPACE_OPEN
-template <typename number>
-SparseILU<number>::SparseILU () = default;
-
-
template <typename number>
template <typename somenumber>
* Destructor. Free all memory, but do not release the memory of the
* sparsity structure.
*/
- ~SparseMatrixEZ ();
+ ~SparseMatrixEZ () = default;
/**
* Pseudo operator only copying empty objects.
}
-template <typename number>
-SparseMatrixEZ<number>::~SparseMatrixEZ() = default;
-
template <typename number>
SparseMatrixEZ<number> &
/**
* Constructor.
*/
- TensorProductMatrixSymmetricSum();
+ TensorProductMatrixSymmetricSum() = default;
/**
* Constructor that is equivalent to the previous constructor and
#ifndef DOXYGEN
-template <int dim, typename Number, int size>
-inline
-TensorProductMatrixSymmetricSum<dim,Number,size>
-::TensorProductMatrixSymmetricSum() = default;
-
-
-
template <int dim, typename Number, int size>
inline
TensorProductMatrixSymmetricSum<dim,Number,size>
* reinit(BlockSparsityPattern). The number of blocks per row and column
* are then determined by that function.
*/
- BlockSparseMatrix ();
+ BlockSparseMatrix () = default;
/**
* Destructor.
* matrices need to be the same.
*/
BlockSparseMatrix &
- operator = (const BlockSparseMatrix &);
+ operator = (const BlockSparseMatrix &) = default;
/**
* This operator assigns a scalar to a matrix. Since this does usually not
/**
* Destructor. Clears memory
*/
- ~BlockVector ();
+ ~BlockVector () = default;
/**
* Copy operator: fill all components of the vector that are locally
/**
* Destructor.
*/
- ~PreconditionBase ();
+ ~PreconditionBase () = default;
/**
* Destroys the preconditioner, leaving an object like just after having
/**
* Destructor.
*/
- virtual ~SolverBase ();
+ virtual ~SolverBase () = default;
/**
* Solve the linear system <tt>Ax=b</tt>. Depending on the information
/**
* Destructor.
*/
- virtual ~SolverDirect ();
+ virtual ~SolverDirect () = default;
/**
* Initializes the direct solver for the matrix <tt>A</tt> and creates a
/**
* Destructor. Made virtual so that one can use pointers to this class.
*/
- virtual ~SparseMatrix ();
+ virtual ~SparseMatrix () = default;
/**
* This function initializes the Trilinos matrix with a deal.II sparsity
/**
* Destructor
*/
- virtual ~TrilinosPayload();
+ virtual ~TrilinosPayload() = default;
/**
* Returns a payload configured for identity operations
/**
* Destructor. Made virtual so that one can use pointers to this class.
*/
- virtual ~SparsityPattern ();
+ virtual ~SparsityPattern () = default;
/**
* Initialize a sparsity pattern that is completely stored locally, having
/**
* Destructor.
*/
- ~Vector ();
+ ~Vector () = default;
/**
* Release all memory and return to a state just like after having called
/**
* Copy constructor.
*/
- DoFInfo (const DoFInfo &dof_info);
+ DoFInfo (const DoFInfo &dof_info) = default;
/**
* Clear all data fields in this class.
- DoFInfo::DoFInfo (const DoFInfo &dof_info_in) = default;
-
-
-
void
DoFInfo::clear ()
{
/**
* Destructor.
*/
- ~MatrixFree();
+ ~MatrixFree() = default;
/**
* Extracts the information needed to perform loops over cells. The
-template <int dim, typename Number>
-MatrixFree<dim,Number>::~MatrixFree() = default;
-
-
-
template <int dim, typename Number>
void MatrixFree<dim,Number>::
copy_from (const MatrixFree<dim,Number> &v)
/**
* The empty virtual destructor.
*/
- ~LocalIntegrator();
+ virtual ~LocalIntegrator() = default;
/**
* Virtual function for integrating on cells. Throws exception
/**
* Constructor
*/
- VectorDataBase();
+ VectorDataBase() = default;
/**
* Constructor from a base class object
/**
* Virtual, but empty destructor.
*/
- virtual ~VectorDataBase();
+ virtual ~VectorDataBase() = default;
/**
* The only function added to VectorSelector is an abstract virtual
namespace MeshWorker
{
- template <int dim, int spacedim, typename Number>
- VectorDataBase<dim, spacedim, Number>::~VectorDataBase() = default;
-
-
-
template <int dim, int spacedim, typename Number>
VectorDataBase<dim, spacedim, Number>::VectorDataBase(const VectorSelector &v)
:
- template <int dim, int spacedim, typename Number>
- VectorDataBase<dim, spacedim, Number>::VectorDataBase() = default;
-
-
-
template <int dim, int spacedim, typename Number>
void
VectorDataBase<dim, spacedim, Number>::initialize(const AnyData &d)
/*
* Virtual destructor.
*/
- virtual ~MGMatrixBase();
+ virtual ~MGMatrixBase() = default;
/**
* Matrix-vector-multiplication on a certain level.
/**
* Virtual destructor.
*/
- virtual ~MGCoarseGridBase ();
+ virtual ~MGCoarseGridBase () = default;
/**
* Solution operator.
/**
* Destructor. Does nothing here, but needs to be declared virtual anyway.
*/
- virtual ~MGTransferBase();
+ virtual ~MGTransferBase() = default;
/**
* Prolongate a vector from level <tt>to_level-1</tt> to level
/**
* Virtual destructor.
*/
- virtual ~MGSmootherBase();
+ virtual ~MGSmootherBase() = default;
/**
* Release matrices.
* Constructor without constraint matrices. Use this constructor only with
* discontinuous finite elements or with no local refinement.
*/
- MGTransferPrebuilt ();
+ MGTransferPrebuilt () = default;
/**
* Constructor with constraints. Equivalent to the default constructor
/**
* Destructor.
*/
- virtual ~MGTransferPrebuilt ();
+ virtual ~MGTransferPrebuilt () = default;
/**
* Initialize the constraints to be used in build_matrices().
/**
* Destructor.
*/
- virtual ~MGTransferBlockSelect ();
+ virtual ~MGTransferBlockSelect () = default;
/**
* Actually build the prolongation matrices for grouped blocks.
/**
* Destructor.
*/
- virtual ~MGTransferSelect ();
+ virtual ~MGTransferSelect () = default;
//TODO: rewrite docs; make sure defaulted args are actually allowed
/**
/**
* Destructor.
*/
- virtual ~MGTransferMatrixFree ();
+ virtual ~MGTransferMatrixFree () = default;
/**
* Initialize the constraints to be used in build().
* Constructor without constraint matrices. Use this constructor only with
* discontinuous finite elements or with no local refinement.
*/
- MGTransferBlockMatrixFree ();
+ MGTransferBlockMatrixFree () = default;
/**
* Constructor with constraints. Equivalent to the default constructor
/**
* Destructor.
*/
- virtual ~MGTransferBlockMatrixFree ();
+ virtual ~MGTransferBlockMatrixFree () = default;
/**
* Initialize the constraints to be used in build().
/**
* Destructor made virtual.
*/
- virtual ~DataEntryBase ();
+ virtual ~DataEntryBase () = default;
/**
* Assuming that the stored vector is a cell vector, extract the given
- template <typename DoFHandlerType>
- DataEntryBase<DoFHandlerType>::~DataEntryBase () = default;
-
-
-
/**
* Class that stores a pointer to a vector of type equal to the template
* argument, and provides the functions to extract data from it.
/**
* Destructor. Only declared to make it @p virtual.
*/
- virtual ~DataOutStack ();
+ virtual ~DataOutStack () = default;
/**
* Start the next set of data for a specific parameter value. The argument
* virtual to ensure that data postprocessors can be destroyed through
* pointers to the base class.
*/
- virtual ~DataPostprocessor ();
+ virtual ~DataPostprocessor () = default;
/**
* This is the main function which actually performs the postprocessing. The
/**
* Destructor. At present, this does nothing.
*/
- virtual ~TimeStepBase ();
+ virtual ~TimeStepBase () = default;
/**
* Reconstruct all the data that is needed for this time level to work. This
namespace Algorithms
{
- OperatorBase::~OperatorBase() = default;
-
-
-
void OperatorBase::notify(const Event &e)
{
notifications += e;
-template <int dim>
-AutoDerivativeFunction<dim>::~AutoDerivativeFunction () = default;
-
-
-
template <int dim>
void
AutoDerivativeFunction<dim>::set_formula (const DifferenceFormula form)
DEAL_II_NAMESPACE_OPEN
-ConvergenceTable::ConvergenceTable() = default;
-
-
-
void ConvergenceTable::evaluate_convergence_rates(const std::string &data_column_key,
const std::string &reference_column_key,
const RateMode rate_mode,
-template <int dim, int spacedim>
-DataOutInterface<dim,spacedim>::~DataOutInterface () = default;
-
-
-
template <int dim, int spacedim>
void DataOutInterface<dim,spacedim>::write_dx (std::ostream &out) const
{
{}
- template <int dim>
- FlowFunction<dim>::~FlowFunction() = default;
-
template <int dim>
void
- template <int dim>
- PoisseuilleFlow<dim>::~PoisseuilleFlow() = default;
-
-
-
template <int dim>
void PoisseuilleFlow<dim>::vector_values (
const std::vector<Point<dim> > &points,
- template <int dim>
- StokesCosine<dim>::~StokesCosine() = default;
-
-
-
template <int dim>
void
StokesCosine<dim>::set_parameters(const double nu, const double r)
- Kovasznay::~Kovasznay() = default;
-
-
-
void Kovasznay::vector_values (
const std::vector<Point<2> > &points,
std::vector<std::vector<double> > &values) const
+// We deliberately delay the definition of the default constructor
+// so that we don't need to include the definition of mu::Parser
+// in the header file.
template <int dim>
FunctionParser<dim>::~FunctionParser() = default;
-ParameterHandler::~ParameterHandler () = default;
-
-
-
std::string
ParameterHandler::mangle (const std::string &s)
{
-MultipleParameterLoop::UserClass::~UserClass () = default;
-
-
-
MultipleParameterLoop::MultipleParameterLoop()
:
n_branches(0)
-MultipleParameterLoop::~MultipleParameterLoop () = default;
-
-
-
void
MultipleParameterLoop::parse_input (std::istream &input,
const std::string &filename,
- PatternBase::~PatternBase () = default;
-
-
-
std::size_t
PatternBase::memory_consumption () const
{
- Anything::Anything () = default;
-
-
-
bool Anything::match (const std::string &) const
{
return true;
- DirectoryName::DirectoryName () = default;
-
-
-
bool DirectoryName::match (const std::string &) const
{
return true;
// inline and template functions
namespace internal
{
- TableEntry::TableEntry () = default;
-
-
double TableEntry::get_numeric_value () const
{
// we don't quite know the data type in 'value', but
- template <int dim, int spacedim>
- Triangulation<dim,spacedim>::~Triangulation () = default;
-
-
-
template <int dim, int spacedim>
void
Triangulation<dim,spacedim>::execute_coarsening_and_refinement ()
- template <int dim, typename VectorType, typename DoFHandlerType>
- SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer () = default;
-
-
-
template <int dim, typename VectorType, typename DoFHandlerType>
void
SolutionTransfer<dim, VectorType, DoFHandlerType>::
-template <int dim, int spacedim>
-FiniteElement<dim,spacedim>::InternalDataBase::~InternalDataBase () = default;
-
-
-
template <int dim, int spacedim>
std::size_t
FiniteElement<dim, spacedim>::InternalDataBase::memory_consumption () const
-FiniteElement<dim,spacedim>::~FiniteElement () = default;
-
-
-
template <int dim, int spacedim>
double
FiniteElement<dim,spacedim>::shape_value (const unsigned int,
-FE_P1NC::~FE_P1NC () = default;
-
-
-
std::vector<unsigned int>
FE_P1NC::get_dpo_vector ()
{
* pointers to the base
* class.
*/
- virtual ~CellIteratorBase ();
+ virtual ~CellIteratorBase () = default;
/**
* Conversion operator to an
Vector<IndexSet::value_type> &out) const = 0;
};
-
-template <int dim, int spacedim>
-FEValuesBase<dim,spacedim>::CellIteratorBase::~CellIteratorBase () = default;
-
/* ---------------- classes derived from FEValuesBase<dim,spacedim>::CellIteratorBase --------- */
DEAL_II_NAMESPACE_OPEN
-template <int dim, int spacedim>
-Mapping<dim, spacedim>::~Mapping () = default;
-
-
template <int dim, int spacedim>
std::array<Point<spacedim>, GeometryInfo<dim>::vertices_per_cell>
Mapping<dim, spacedim>::get_vertices (
-template <int dim, int spacedim>
-Mapping<dim, spacedim>::InternalDataBase::~InternalDataBase () = default;
-
-
-
template <int dim, int spacedim>
std::size_t
Mapping<dim, spacedim>::InternalDataBase::memory_consumption () const
DEAL_II_NAMESPACE_OPEN
-template <int dim, int spacedim>
-MappingManifold<dim,spacedim>::InternalData::InternalData () = default;
-
-
template <int dim, int spacedim>
std::size_t
MappingManifold<dim,spacedim>::InternalData::memory_consumption () const
-template <int dim, int spacedim>
-MappingManifold<dim,spacedim>::MappingManifold () = default;
-
-
-
template <int dim, int spacedim>
MappingManifold<dim,spacedim>::MappingManifold (const MappingManifold<dim,spacedim> &)
{}
using namespace Manifolds;
/* -------------------------- Manifold --------------------- */
-template <int dim, int spacedim>
-Manifold<dim, spacedim>::~Manifold () = default;
-
-
-
template <int dim, int spacedim>
Point<spacedim>
Manifold<dim, spacedim>::
/* -------------------------- ChartManifold --------------------- */
-
-template <int dim, int spacedim, int chartdim>
-ChartManifold<dim,spacedim,chartdim>::~ChartManifold () = default;
-
-
-
template <int dim, int spacedim, int chartdim>
ChartManifold<dim,spacedim,chartdim>::ChartManifold (const Tensor<1,chartdim> &periodicity)
:
-template <int dim, int spacedim>
-PersistentTriangulation<dim,spacedim>::~PersistentTriangulation () = default;
-
-
-
template <int dim, int spacedim>
void
PersistentTriangulation<dim,spacedim>::execute_coarsening_and_refinement ()
/* -------------------------- Boundary --------------------- */
-template <int dim, int spacedim>
-Boundary<dim, spacedim>::~Boundary () = default;
-
-
template <int dim, int spacedim>
void
Boundary<dim, spacedim>::
/* -------------------------- StraightBoundary --------------------- */
-template <int dim, int spacedim>
-StraightBoundary<dim, spacedim>::StraightBoundary () = default;
-
-
template <int dim, int spacedim>
Point<spacedim>
StraightBoundary<dim, spacedim>::
return numbers::invalid_unsigned_int;
}
- template <int dim, int spacedim>
- FECollection<dim,spacedim>::FECollection () = default;
-
template <int dim, int spacedim>
namespace hp
{
-
- template <int dim, int spacedim>
- MappingCollection<dim,spacedim>::MappingCollection () = default;
-
-
-
template <int dim, int spacedim>
MappingCollection<dim,spacedim>::
MappingCollection (const Mapping<dim,spacedim> &mapping)
-BlockSparsityPattern::BlockSparsityPattern () = default;
-
-
-
BlockSparsityPattern::BlockSparsityPattern (const size_type n_rows,
const size_type n_columns)
:
-
-BlockDynamicSparsityPattern::BlockDynamicSparsityPattern () = default;
-
-
-
BlockDynamicSparsityPattern::
BlockDynamicSparsityPattern (const size_type n_rows,
const size_type n_columns)
namespace TrilinosWrappers
{
- BlockSparsityPattern::BlockSparsityPattern () = default;
-
-
-
BlockSparsityPattern::
BlockSparsityPattern (const size_type n_rows,
const size_type n_columns)
-ChunkSparsityPattern::~ChunkSparsityPattern () = default;
-
-
-
ChunkSparsityPattern &
ChunkSparsityPattern::operator = (const ChunkSparsityPattern &s)
{
-MatrixOut::~MatrixOut () = default;
-
-
-
const std::vector<MatrixOut::Patch> &
MatrixOut::get_patches () const
{
namespace MPI
{
- BlockSparseMatrix::BlockSparseMatrix () = default;
-
-
- BlockSparseMatrix::~BlockSparseMatrix () = default;
-
-
BlockSparseMatrix &
BlockSparseMatrix::operator = (const BlockSparseMatrix &m)
{
}
- PreconditionJacobi::PreconditionJacobi () = default;
-
PreconditionJacobi::PreconditionJacobi (const MatrixBase &matrix,
const AdditionalData &additional_data)
}
- PreconditionBlockJacobi::PreconditionBlockJacobi () = default;
-
PreconditionBlockJacobi::
PreconditionBlockJacobi (const MatrixBase &matrix,
{}
- PreconditionSOR::PreconditionSOR () = default;
-
PreconditionSOR::PreconditionSOR (const MatrixBase &matrix,
const AdditionalData &additional_data)
{}
- PreconditionSSOR::PreconditionSSOR () = default;
-
PreconditionSSOR::PreconditionSSOR (const MatrixBase &matrix,
const AdditionalData &additional_data)
{}
- PreconditionEisenstat::PreconditionEisenstat () = default;
-
PreconditionEisenstat::PreconditionEisenstat (const MatrixBase &matrix,
const AdditionalData &additional_data)
{}
- PreconditionICC::PreconditionICC () = default;
-
PreconditionICC::PreconditionICC (const MatrixBase &matrix,
const AdditionalData &additional_data)
{}
- PreconditionILU::PreconditionILU () = default;
-
PreconditionILU::PreconditionILU (const MatrixBase &matrix,
const AdditionalData &additional_data)
{}
- PreconditionBoomerAMG::PreconditionBoomerAMG () = default;
PreconditionBoomerAMG::PreconditionBoomerAMG (const MPI_Comm comm,
const AdditionalData &additional_data_)
{}
- PreconditionParaSails::PreconditionParaSails () = default;
-
PreconditionParaSails::PreconditionParaSails (const MatrixBase &matrix,
const AdditionalData &additional_data)
/* ----------------- PreconditionNone ------------------------- */
- PreconditionNone::PreconditionNone () = default;
-
-
PreconditionNone::PreconditionNone (const MatrixBase &matrix,
const AdditionalData &additional_data)
{
{}
- PreconditionLU::PreconditionLU () = default;
-
PreconditionLU::PreconditionLU (const MatrixBase &matrix,
const AdditionalData &additional_data)
- SolverBase::~SolverBase () = default;
-
-
-
void
SolverBase::solve (const MatrixBase &A,
VectorBase &x,
-SolverControl::~SolverControl() = default;
-
-
-
SolverControl::State
SolverControl::check (const unsigned int step,
const double check_value)
}
-ReductionControl::~ReductionControl() = default;
-
SolverControl::State
ReductionControl::check (const unsigned int step,
SolverControl (n, tolerance, m_log_history, m_log_result) {}
-IterationNumberControl::~IterationNumberControl() = default;
SolverControl::State
-ConsecutiveControl::~ConsecutiveControl() = default;
-
-
SolverControl::State
ConsecutiveControl::check (const unsigned int step,
const double check_value)
namespace TrilinosWrappers
{
- BlockSparseMatrix::BlockSparseMatrix () = default;
-
-
-
BlockSparseMatrix::~BlockSparseMatrix ()
{
// delete previous content of
- BlockSparseMatrix &
- BlockSparseMatrix::operator = (const BlockSparseMatrix &m) = default;
-
-
-
void
BlockSparseMatrix::
reinit (const size_type n_block_rows,
-
- BlockVector::~BlockVector () = default;
-
-
-
void
BlockVector::reinit (const std::vector<IndexSet> ¶llel_partitioning,
const MPI_Comm &communicator,
- PreconditionBase::~PreconditionBase() = default;
-
-
-
void PreconditionBase::clear ()
{
preconditioner.reset();
- SolverBase::~SolverBase () = default;
-
-
-
SolverControl &
SolverBase::control() const
{
- SolverDirect::~SolverDirect () = default;
-
-
-
SolverControl &
SolverDirect::control() const
{
- SparseMatrix::~SparseMatrix () = default;
-
-
-
void
SparseMatrix::copy_from (const SparseMatrix &rhs)
{
- // Destructor
- TrilinosPayload::~TrilinosPayload () = default;
-
-
-
TrilinosPayload
TrilinosPayload::identity_payload () const
{
- SparsityPattern::~SparsityPattern () = default;
-
-
-
void
SparsityPattern::reinit (const size_type m,
const size_type n,
- Vector::~Vector () = default;
-
-
-
void
Vector::clear ()
{
{}
- template <int dim, int spacedim, typename number>
- LocalIntegrator<dim, spacedim, number>::~LocalIntegrator () = default;
template <int dim, int spacedim, typename number>
void
DEAL_II_NAMESPACE_OPEN
-template <typename VectorType>
-MGTransferBase<VectorType>::~MGTransferBase() = default;
-
-
-template <typename VectorType>
-MGMatrixBase<VectorType>::~MGMatrixBase() = default;
-
-
-template <typename VectorType>
-MGSmootherBase<VectorType>::~MGSmootherBase() = default;
-
-
template <typename VectorType>
void
MGSmootherBase<VectorType>::apply (const unsigned int level,
}
-template <typename VectorType>
-MGCoarseGridBase<VectorType>::~MGCoarseGridBase() = default;
-
-
// Explicit instantiations
#include "mg_base.inst"
-template <int dim, typename Number>
-MGTransferMatrixFree<dim,Number>::~MGTransferMatrixFree () = default;
-
-
-
template <int dim, typename Number>
void MGTransferMatrixFree<dim,Number>::initialize_constraints
(const MGConstrainedDoFs &mg_c)
}
-template <int dim, typename Number>
-MGTransferBlockMatrixFree<dim,Number>::MGTransferBlockMatrixFree () = default;
-
-
template <int dim, typename Number>
MGTransferBlockMatrixFree<dim,Number>::MGTransferBlockMatrixFree (const MGConstrainedDoFs &mg_c)
-template <int dim, typename Number>
-MGTransferBlockMatrixFree<dim,Number>::~MGTransferBlockMatrixFree () = default;
-
-
-
template <int dim, typename Number>
void MGTransferBlockMatrixFree<dim,Number>::initialize_constraints
(const MGConstrainedDoFs &mg_c)
DEAL_II_NAMESPACE_OPEN
-template <typename VectorType>
-MGTransferPrebuilt<VectorType>::MGTransferPrebuilt () = default;
-
-
-
template <typename VectorType>
MGTransferPrebuilt<VectorType>::MGTransferPrebuilt (const MGConstrainedDoFs &mg_c)
{
-template <typename VectorType>
-MGTransferPrebuilt<VectorType>::~MGTransferPrebuilt () = default;
-
-
-
template <typename VectorType>
void MGTransferPrebuilt<VectorType>::initialize_constraints
(const MGConstrainedDoFs &mg_c)
constraints(&c)
{}
-template <typename number>
-MGTransferSelect<number>::~MGTransferSelect () = default;
template <typename number>
-template <typename number>
-MGTransferBlockSelect<number>::~MGTransferBlockSelect () = default;
-
-
-
template <typename number>
void
MGTransferBlockSelect<number>::prolongate (const unsigned int to_level,
-template <int dim, int spacedim, typename DoFHandlerType>
-DataOutStack<dim,spacedim,DoFHandlerType>::~DataOutStack () = default;
-
-
template <int dim, int spacedim, typename DoFHandlerType>
void DataOutStack<dim,spacedim,DoFHandlerType>::new_parameter_value (const double p,
const double dp)
// -------------------------- DataPostprocessor ---------------------------
-template <int dim>
-DataPostprocessor<dim>::~DataPostprocessor() = default;
-
-
-
template <int dim>
void
DataPostprocessor<dim>::
-TimeStepBase::~TimeStepBase () = default;
-
-
-
void
TimeStepBase::wake_up (const unsigned int )
{}
projects / dealii.git / commitdiff