*
* @deprecated use Functions::ConstantFunction instead.
*/
-template<int dim, typename Number=double>
+template <int dim, typename Number=double>
using ConstantFunction DEAL_II_DEPRECATED = Functions::ConstantFunction<dim,Number>;
/**
*
* @deprecated use Functions::ZeroFunction instead.
*/
-template<int dim, typename Number=double>
+template <int dim, typename Number=double>
using ZeroFunction DEAL_II_DEPRECATED = Functions::ZeroFunction<dim,Number>;
return minlevel + objects.size() - 1;
}
-template<class Object>
+template <class Object>
template <typename ActionFunctionObjectType>
void
MGLevelObject<Object>::apply (ActionFunctionObjectType action)
* Compute the inverse of a symmetric tensor of a
* generic @p rank, @p dim and @p Number type.
*/
- template<int rank, int dim, typename Number>
+ template <int rank, int dim, typename Number>
struct Inverse;
}
* <tt>symmetrize</tt> function first. If you aren't sure, it is good
* practice to check before calling <tt>symmetrize</tt>.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
explicit
SymmetricTensor (const Tensor<2,dim,OtherNumber> &t);
* as this operator, but rather than returning the result as a return value,
* they write it into the first argument to the function.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
typename internal::SymmetricTensorAccessors::double_contraction_result<rank,2,dim,Number,OtherNumber>::type
operator * (const SymmetricTensor<2,dim,OtherNumber> &s) const;
* Contraction over two indices of the present object with the rank-4
* symmetric tensor given as argument.
*/
- template<typename OtherNumber>
+ template <typename OtherNumber>
typename internal::SymmetricTensorAccessors::double_contraction_result<rank,4,dim,Number,OtherNumber>::type
operator * (const SymmetricTensor<4,dim,OtherNumber> &s) const;
template <int rank, int dim, typename Number>
-template<typename OtherNumber>
+template <typename OtherNumber>
inline
SymmetricTensor<rank,dim,Number>::SymmetricTensor (const Tensor<2,dim,OtherNumber> &t)
{
}
- template<typename Number>
+ template <typename Number>
struct Inverse<2,1,Number>
{
static inline dealii::SymmetricTensor<2,1,Number>
};
- template<typename Number>
+ template <typename Number>
struct Inverse<2,2,Number>
{
static inline dealii::SymmetricTensor<2,2,Number>
};
- template<typename Number>
+ template <typename Number>
struct Inverse<2,3,Number>
{
static dealii::SymmetricTensor<2,3,Number>
};
- template<typename Number>
+ template <typename Number>
struct Inverse<4,1,Number>
{
static inline dealii::SymmetricTensor<4,1,Number>
};
- template<typename Number>
+ template <typename Number>
struct Inverse<4,2,Number>
{
static inline dealii::SymmetricTensor<4,2,Number>
};
- template<typename Number>
+ template <typename Number>
struct Inverse<4,3,Number>
{
static dealii::SymmetricTensor<4,3,Number>
template <int rank, int dim, typename Number>
-template<typename OtherNumber>
+template <typename OtherNumber>
inline
typename internal::SymmetricTensorAccessors::double_contraction_result<rank,2,dim,Number,OtherNumber>::type
SymmetricTensor<rank,dim,Number>::operator * (const SymmetricTensor<2,dim,OtherNumber> &s) const
template <int rank, int dim, typename Number>
-template<typename OtherNumber>
+template <typename OtherNumber>
inline
typename internal::SymmetricTensorAccessors::double_contraction_result<rank,4,dim,Number,OtherNumber>::type
SymmetricTensor<rank,dim,Number>::operator * (const SymmetricTensor<4,dim,OtherNumber> &s) const
* A struct that is used to sort arrays of pairs of eign=envalues and
* eigenvectors. Sorting is performed in in descending order of eigenvalue.
*/
- template<int dim, typename Number>
+ template <int dim, typename Number>
struct SortEigenValuesVectors
{
typedef std::pair<Number, Tensor<1,dim,Number> > EigValsVecs;
namespace
{
// helper struct for is_base_of_all
- template<bool... Types> struct BoolStorage;
+ template <bool... Types> struct BoolStorage;
}
/**
* classes have Base as base class or are Base itself. The result
* is stored in the member variable value.
*/
-template<class Base, class... Derived>
+template <class Base, class... Derived>
struct is_base_of_all
{
static constexpr bool value =
* Constructor. This constructor creates a FECollection from more than
* one finite element.
*/
- template<class... FETypes>
+ template <class... FETypes>
explicit FECollection (const FETypes &... fes);
/**
{
// LAPACKFullMatrix is not implemented for
// complex numbers or long doubles
- template<typename number, typename = void>
+ template <typename number, typename = void>
struct Determinant
{
static number value (const FullMatrix<number> &)
// LAPACKFullMatrix is only implemented for
// floats and doubles
- template<typename number>
+ template <typename number>
struct Determinant<number, typename std::enable_if<
std::is_same<number,float>::value ||
std::is_same<number,double>::value
*
* @author Vishal Boddu, Denis Davydov, 2017
*/
-template<typename VectorType = Vector<double> >
+template <typename VectorType = Vector<double> >
class SolverFIRE : public Solver<VectorType>
{
* passed in as first argument based on the second argument-- the state of
* variables.
*/
- template<typename PreconditionerType = DiagonalMatrix<VectorType>>
+ template <typename PreconditionerType = DiagonalMatrix<VectorType>>
void solve
(const std::function<double(VectorType &, const VectorType &)> &compute,
VectorType &x,
* when $E(\mathbf x)
* = \frac{1}{2} \mathbf x^{T} \mathbf A \mathbf x - \mathbf x^{T} \mathbf b$.
*/
- template<typename MatrixType, typename PreconditionerType>
+ template <typename MatrixType, typename PreconditionerType>
void solve (const MatrixType &A,
VectorType &x,
const VectorType &b,
#ifndef DOXYGEN
-template<typename VectorType>
+template <typename VectorType>
SolverFIRE<VectorType>::AdditionalData::
AdditionalData (const double initial_timestep,
const double maximum_timestep,
-template<typename VectorType>
+template <typename VectorType>
SolverFIRE<VectorType>::
SolverFIRE (SolverControl &solver_control,
VectorMemory<VectorType> &vector_memory,
-template<typename VectorType>
+template <typename VectorType>
SolverFIRE<VectorType>::
SolverFIRE (SolverControl &solver_control,
const AdditionalData &data )
-template<typename VectorType>
+template <typename VectorType>
SolverFIRE<VectorType>::~SolverFIRE()
{}
-template<typename VectorType>
-template<typename PreconditionerType>
+template <typename VectorType>
+template <typename PreconditionerType>
void
SolverFIRE<VectorType>::solve
(const std::function<double(VectorType &, const VectorType &)> &compute,
template <typename VectorType>
-template<typename MatrixType, typename PreconditionerType>
+template <typename MatrixType, typename PreconditionerType>
void SolverFIRE<VectorType>::solve (const MatrixType &A,
VectorType &x,
const VectorType &b,
*
* @author Simon Sticko, 2017
*/
- template<int dim>
+ template <int dim>
class ImmersedSurfaceQuadrature : public Quadrature<dim>
{
public:
*
* @author Luca Heltai, 2017.
*/
-template<int dim>
+template <int dim>
class KDTree
{
public:
//------------ inline functions -------------
#ifndef DOXYGEN
-template<int dim>
+template <int dim>
inline
unsigned int KDTree<dim>::size() const
{
-template<int dim>
+template <int dim>
inline const Point<dim> &
KDTree<dim>::operator[](unsigned int i) const
{
-template<int dim>
+template <int dim>
KDTree<dim>::PointCloudAdaptor::PointCloudAdaptor(const std::vector<Point<dim> > &_points)
: points(_points)
{}
-template<int dim>
+template <int dim>
inline size_t
KDTree<dim>::PointCloudAdaptor::kdtree_get_point_count() const
{
-template<int dim>
+template <int dim>
inline double
KDTree<dim>::PointCloudAdaptor::kdtree_get_pt(const size_t idx, int d) const
{
-template<int dim>
+template <int dim>
template <class BBOX>
inline bool
KDTree<dim>::PointCloudAdaptor::kdtree_get_bbox(BBOX &) const
-template<int dim>
+template <int dim>
inline double
KDTree<dim>::PointCloudAdaptor::kdtree_distance(const double *p1, const size_t idx_p2,size_t size) const
{
namespace NonMatching
{
- template<int dim>
+ template <int dim>
ImmersedSurfaceQuadrature<dim>::ImmersedSurfaceQuadrature(
const std::vector<Point<dim> > &points,
const std::vector<double> &weights,
- template<int dim>
+ template <int dim>
void ImmersedSurfaceQuadrature<dim>::push_back(
const Point<dim> &point,
const double weight,
- template<int dim>
+ template <int dim>
const Tensor<1,dim> &
ImmersedSurfaceQuadrature<dim>::normal_vector(
const unsigned int i) const
- template<int dim>
+ template <int dim>
const std::vector<Tensor<1,dim> > &
ImmersedSurfaceQuadrature<dim>::get_normal_vectors() const
{
DEAL_II_NAMESPACE_OPEN
-template<int dim>
+template <int dim>
KDTree<dim>::KDTree(const unsigned int &max_leaf_size,
const std::vector<Point<dim> > &pts)
: max_leaf_size(max_leaf_size)
}
-template<int dim>
+template <int dim>
std::vector<std::pair<unsigned int, double> > KDTree<dim>::get_points_within_ball(const Point<dim> ¢er,
const double &radius,
bool sorted) const
return matches;
}
-template<int dim>
+template <int dim>
std::vector<std::pair<unsigned int, double> > KDTree<dim>::get_closest_points(const Point<dim> &target,
const unsigned int n_points) const
{
return matches;
}
-template<int dim>
+template <int dim>
void KDTree<dim>::set_points(const std::vector<Point<dim> > &pts)
{
Assert(pts.size() > 0, ExcMessage("Expecting a non zero set of points."));
// Try conversion on elementary types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on non elementary types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on container types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on map types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on complex map types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on complex map types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on arbitrary container types
-template<class T>
+template <class T>
void test(T t)
{
auto p = Convert<T>::to_pattern();
// Try conversion on elementary types
-template<class T>
+template <class T>
void test(T t, std::string s)
{
auto p = Convert<T>::to_pattern();
}
};
-template<int dim>
+template <int dim>
bool
is_unit_vector(const Tensor<1,dim> &v)
{
return std::abs(v.norm() - 1.0) < 1e-9;
}
-template<int dim>
+template <int dim>
bool
check_orientation(Tensor<1,dim> v1,
Tensor<1,dim> v2)
}
};
-template<int dim>
+template <int dim>
bool
is_unit_vector(const Tensor<1,dim> &v)
{
return std::abs(v.norm() - 1.0) < 1e-9;
}
-template<int dim>
+template <int dim>
bool
check_orientation(Tensor<1,dim> v1,
Tensor<1,dim> v2,
return std::abs(std::abs(v1*v2) - 1.0) < tol;
}
-template<int dim>
+template <int dim>
void
check_vector (const int index,
const Tensor<1,dim> expected, const Tensor<1,dim> actual,
}
template <int dim,
- template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+ template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
void print (const TensorType1<2,dim,NumberType1> &t2,
const TensorType2<4,dim,NumberType2> &t4)
{
}
template <int dim,
- template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+ template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
void print (const TensorType1<2,dim,NumberType1> &t2_1,
const TensorType2<2,dim,NumberType2> &t2_2,
const TensorType1<4,dim,NumberType1> &t4_1,
}
-template<template<int,int,typename> class TensorType1,
- template<int,int,typename> class TensorType2>
+template <template <int,int,typename> class TensorType1,
+ template <int,int,typename> class TensorType2>
struct AreSame : std::false_type
{};
-template<template<int,int,typename> class TensorType1>
+template <template <int,int,typename> class TensorType1>
struct AreSame<TensorType1,TensorType1> : std::true_type
{};
-template<template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+template <template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
void test_one ()
{
const unsigned int dim = 2;
deallog << scalar_product(t2_1,t2_2) << std::endl;
}
-template<template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+template <template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
typename std::enable_if<AreSame<TensorType1,TensorType2>::value>::type
test_two ()
{
deallog << (t4_1*t4_2) << std::endl;
}
-template<template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+template <template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
typename std::enable_if<!AreSame<TensorType1,TensorType2>::value>::type
test_two ()
{}
-template<template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+template <template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
typename std::enable_if<(
AreSame<TensorType1,SymmetricTensor>::value &&
AreSame<TensorType2,SymmetricTensor>::value)>::type
deallog << res_dc << std::endl;
}
-template<template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+template <template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
typename std::enable_if<!(
AreSame<TensorType1,SymmetricTensor>::value &&
AreSame<TensorType2,SymmetricTensor>::value)>::type
{}
-template<template<int,int,typename> class TensorType1, typename NumberType1,
- template<int,int,typename> class TensorType2, typename NumberType2>
+template <template <int,int,typename> class TensorType1, typename NumberType1,
+ template <int,int,typename> class TensorType2, typename NumberType2>
void test_all ()
{
test_one<TensorType1,NumberType1,TensorType2,NumberType2>();
test_three<TensorType1,NumberType1,TensorType2,NumberType2>();
}
-template<typename Number1, typename Number2>
+template <typename Number1, typename Number2>
void test_T ()
{
deallog.push("ST,ST");
#include <fstream>
#include <type_traits>
-template<typename NumberType, int dim, typename ExtractorType>
+template <typename NumberType, int dim, typename ExtractorType>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
const std::vector<NumberType> &local_dof_values);
// Scalar view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
// Vector view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
// SymmetricTensor view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
// Tensor view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
}
-template<typename NumberType, int dim, typename FEType, typename ExtractorType>
+template <typename NumberType, int dim, typename FEType, typename ExtractorType>
void test_extractor (const FEType &fe,
const ExtractorType &extractor)
{
deallog << "OK" << std::endl;
}
-template<typename NumberType, int dim = 2>
+template <typename NumberType, int dim = 2>
void test()
{
const unsigned int degree = 3; // Need third derivatives
#include <fstream>
#include <type_traits>
-template<typename NumberType, int dim, typename ExtractorType>
+template <typename NumberType, int dim, typename ExtractorType>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
const std::vector<NumberType> &local_dof_values);
// Scalar view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
// Vector view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
// SymmetricTensor view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
}
// Tensor view
-template<typename NumberType, int dim>
+template <typename NumberType, int dim>
void test_view (const Vector<double> &solution,
const FEValues<dim> &fe_values,
const unsigned int &n_q_points,
fe_values_view.get_function_divergences_from_local_dof_values(local_dof_values, qp_divs_local);
}
-template<typename NumberType, int dim, typename FEType, typename ExtractorType>
+template <typename NumberType, int dim, typename FEType, typename ExtractorType>
void test_extractor (const FEType &fe,
const ExtractorType &extractor)
{
deallog << "OK" << std::endl;
}
-template<typename NumberType, int dim = 2>
+template <typename NumberType, int dim = 2>
void test()
{
const unsigned int degree = 3; // Need third derivatives
using namespace MeshWorker;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
Triangulation<dim,spacedim> tria;
using namespace MeshWorker;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
Triangulation<dim,spacedim> tria;
using namespace MeshWorker;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD,
using namespace MeshWorker;
-template<int dim, int spacedim>
+template <int dim, int spacedim>
void test()
{
parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
-template<int dim>
+template <int dim>
void print_quadrature(const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature)
{
for (unsigned int i = 0; i < quadrature.size(); ++i)
//Check that get_normals() are callable and are of the same size as
//points and weights.
-template<int dim>
+template <int dim>
void check_get_normals(
const NonMatching::ImmersedSurfaceQuadrature<dim> &quadrature)
{
-template<int dim>
+template <int dim>
void test_non_default_constructor()
{
deallog<<"Using constructor"<<std::endl;
-template<int dim>
+template <int dim>
void test_push_back()
{
deallog<<"Using push_back"<<std::endl;
-template<int dim>
+template <int dim>
void construct_quadrature_and_print_points()
{
test_push_back<dim>();