AC_MSG_RESULT(C++ compiler is gcc-3.2)
GXX_VERSION=gcc3.2
;;
+ *3.3*)
+ AC_MSG_RESULT(C++ compiler is gcc-3.3)
+ GXX_VERSION=gcc3.3
+ ;;
*2.4* | *2.5* | *2.6* | *2.7* | *2.8*)
dnl These compilers are too old to support a useful subset
dnl of modern C++, so we don't support them
AC_MSG_RESULT(F77 compiler is gcc-3.2)
F77_VERSION=gcc3.2
;;
+ *3.3*)
+ AC_MSG_RESULT(F77 compiler is gcc-3.3)
+ F77_VERSION=gcc3.3
+ ;;
*2.4* | *2.5* | *2.6* | *2.7* | *2.8*)
dnl These compilers are too old to support a useful subset
- dnl of modern C++, so we don't support them
+ dnl of modern C++, so we don't support them. gcc2.7.2 is
+ dnl probably the only one that around on reasonably modern
+ dnl systems these times, but maybe someone tries to run
+ dnl deal.II on really old systems?
AC_MSG_RESULT(F77 compiler is $G77_VERSION_STRING)
AC_MSG_ERROR(F77 compiler is not supported)
;;
AC_DEFUN(DEAL_II_SET_F77_FLAGS, dnl
[
case "$F77_VERSION" in
- egcs-1.1 | gcc2.95 | gcc2.96 | gcc2.97 | gcc3.0 | gcc3.1 | gcc3.2)
+ egcs-1.1 | gcc2.95 | gcc2.96 | gcc2.97 | gcc3.[0123])
F77FLAGSG="$FFLAGS -ggdb -DDEBUG -pedantic -W -Wall"
F77FLAGSO="$FFLAGS -O2"
* @p{formula}.
*/
virtual void vector_gradient (const Point<dim> &p,
- typename std::vector<Tensor<1,dim> > &gradients) const;
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Set @p{gradients} to the
* @p{DifferenceFormula}
* @p{formula}.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
* @p{DifferenceFormula}
* @p{formula}.
*/
- virtual void vector_gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const;
+ virtual void vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
/**
* Returns a
* Includes the unit vectors
* scaled by @p{h}.
*/
- typename std::vector<Tensor<1,dim> > ht;
+ std::vector<Tensor<1,dim> > ht;
/**
* Difference formula. Set by the
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_dx (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_dx (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const DXFlags &flags,
std::ostream &out);
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_ucd (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_ucd (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const UcdFlags &flags,
std::ostream &out);
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_gnuplot (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_gnuplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const GnuplotFlags &flags,
std::ostream &out);
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_povray (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_povray (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const PovrayFlags &flags,
std::ostream &out);
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_eps (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_eps (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const EpsFlags &flags,
std::ostream &out);
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_gmv (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_gmv (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const GmvFlags &flags,
std::ostream &out);
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_tecplot (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_tecplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const TecplotFlags &flags,
std::ostream &out);
* ASCII output is still produced.
*/
template <int dim, int spacedim>
- static void write_tecplot_binary (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_tecplot_binary (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const TecplotFlags &flags,
std::ostream &out);
* information on the parameters.
*/
template <int dim, int spacedim>
- static void write_vtk (const typename std::vector<Patch<dim,spacedim> > &patches,
+ static void write_vtk (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const VtkFlags &flags,
std::ostream &out);
*/
template <int dim, int spacedim>
static void
- write_gmv_reorder_data_vectors (const typename std::vector<Patch<dim,spacedim> > &patches,
+ write_gmv_reorder_data_vectors (const std::vector<Patch<dim,spacedim> > &patches,
std::vector<std::vector<double> > &data_vectors);
};
* output functions to know what
* they shall print.
*/
- virtual const typename std::vector<typename DataOutBase::Patch<dim,spacedim> > &
+ virtual const std::vector<typename DataOutBase::Patch<dim,spacedim> > &
get_patches () const = 0;
/**
* right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
* the same number of components
* as this function has.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
/**
* function at the given point.
*/
virtual void vector_gradient (const Point<dim> &p,
- typename std::vector<Tensor<1,dim> > &gradients) const;
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Set @p{gradients} to the
* right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
* over the different components
* of the function.
*/
- virtual void vector_gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const;
+ virtual void vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
/**
* Compute the Laplacian of a
* Compute the Laplacian of one
* component at a set of points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
* Compute the Laplacians of all
* components at a set of points.
*/
- virtual void vector_laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_laplacian_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
/**
* the same size as the @p{points}
* array.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
* the same size as the @p{points}
* array.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
/**
* for all components.
*/
virtual void vector_gradient (const Point<dim> &p,
- typename std::vector<Tensor<1,dim> > &gradients) const;
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Set @p{gradients} to the gradients of
* already has the right size, i.e.
* the same size as the @p{points} array.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
* over the different components
* of the function.
*/
- virtual void vector_gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const;
+ virtual void vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
};
* the same size as the @p{points}
* array.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
* the same size as the @p{points}
* array.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
/**
* the same size as the @p{points}
* array.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
/**
* values are accessed.
*/
FunctionDerivative (const Function<dim> &f,
- const typename std::vector<Point<dim> > &direction,
+ const std::vector<Point<dim> > &direction,
const double h = 1.e-6);
/**
* Function values at multiple
* points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
* increment vector for the
* formula.
*/
- typename std::vector<Point<dim> > incr;
+ std::vector<Point<dim> > incr;
};
#endif
/**
* Function values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
Gradients at multiple points.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
/**
* Laplacian of the function at multiple points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
Gradients at multiple points.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
/**
* Laplacian of the function at multiple points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
private:
/**
* Values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Gradients at multiple points.
*/
- virtual void hessian_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<2,dim> > &hessians,
+ virtual void hessian_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<2,dim> > &hessians,
const unsigned int component = 0) const;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
Gradients at multiple points.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
/**
* Laplacian of the function at multiple points.
*/
- virtual void laplacian_list (const typename std::vector<Point<dim> > &points,
+ virtual void laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
* coefficients in each space
* direction as argument.
*/
- FourierSineSum (const typename std::vector<Point<dim> > &fourier_coefficients,
+ FourierSineSum (const std::vector<Point<dim> > &fourier_coefficients,
const std::vector<double> &weights);
/**
* Stored Fourier coefficients
* and weights.
*/
- const typename std::vector<Point<dim> > fourier_coefficients;
+ const std::vector<Point<dim> > fourier_coefficients;
const std::vector<double> weights;
};
* coefficients in each space
* direction as argument.
*/
- FourierCosineSum (const typename std::vector<Point<dim> > &fourier_coefficients,
+ FourierCosineSum (const std::vector<Point<dim> > &fourier_coefficients,
const std::vector<double> &weights);
/**
* Stored Fourier coefficients
* and weights.
*/
- const typename std::vector<Point<dim> > fourier_coefficients;
+ const std::vector<Point<dim> > fourier_coefficients;
const std::vector<double> weights;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Function values at multiple points.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Function values at multiple points.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
+ virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
* Function values at multiple points.
*/
- virtual void vector_value_list (const typename std::vector<Point<dim> > &points,
+ virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const;
/**
*/
template <typename T>
inline
- unsigned int memory_consumption (const typename std::vector<T> &v);
+ unsigned int memory_consumption (const std::vector<T> &v);
/**
* Estimate the amount of memory
*/
template <typename T>
inline
- unsigned int memory_consumption (const typename std::vector<T *> &v);
+ unsigned int memory_consumption (const std::vector<T *> &v);
/**
* Specialization of the
*/
template <typename A, typename B>
inline
- unsigned int memory_consumption (const typename std::pair<A,B> &p);
+ unsigned int memory_consumption (const std::pair<A,B> &p);
/**
* Return the amount of memory
#endif
template <typename T>
- unsigned int memory_consumption (const typename std::vector<T> &v)
+ unsigned int memory_consumption (const std::vector<T> &v)
{
unsigned int mem = sizeof(std::vector<T>);
const unsigned int n = v.size();
template <typename T>
inline
- unsigned int memory_consumption (const typename std::vector<T *> &v)
+ unsigned int memory_consumption (const std::vector<T *> &v)
{
return (v.capacity() * sizeof(T *) +
sizeof(v));
template <typename A, typename B>
inline
- unsigned int memory_consumption (const typename std::pair<A,B> &p)
+ unsigned int memory_consumption (const std::pair<A,B> &p)
{
return (memory_consumption(p.first) +
memory_consumption(p.second));
* the @p{coefficient} array
* minus one.
*/
- Polynomial (const typename std::vector<number> &coefficients);
+ Polynomial (const std::vector<number> &coefficients);
/**
* Return the value of this
* scheme for numerical stability
* of the evaluation.
*/
- void value (const number x,
- typename std::vector<number> &values) const;
+ void value (const number x,
+ std::vector<number> &values) const;
/**
* Degree of the polynomial. This
protected:
/**
- * This function performs the actual scaling.
+ * This function performs the
+ * actual scaling.
*/
- static void scale (typename std::vector<number>& coefficients,
- const number factor);
+ static void scale (std::vector<number> &coefficients,
+ const number factor);
/**
- * This function performs the actual shift
+ * This function performs the
+ * actual shift
*/
template <typename number2>
- static void shift (typename std::vector<number>& coefficients,
- const number2 shift);
+ static void shift (std::vector<number> &coefficients,
+ const number2 shift);
/**
* Multiply polynomial by a factor.
*/
- static void multiply (typename std::vector<number>& coefficients,
+ static void multiply (std::vector<number>& coefficients,
const number factor);
/**
* since we want to allow copying
* of polynomials.
*/
- typename std::vector<number> coefficients;
+ std::vector<number> coefficients;
};
/**
* Coefficients for the interval $[0,1]$.
*/
- static typename std::vector<const typename std::vector<number> *> shifted_coefficients;
+ static std::vector<const std::vector<number> *> shifted_coefficients;
/**
* Vector with already computed
* vectors in order to simplify
* programming multithread-safe.
*/
- static typename std::vector<const typename std::vector<number> *> recursive_coefficients;
+ static std::vector<const std::vector<number> *> recursive_coefficients;
/**
* Compute coefficients recursively.
* constructor of
* @ref{Polynomial}.
*/
- static const typename std::vector<number> &
+ static const std::vector<number> &
get_coefficients (const unsigned int k);
};
* @p{Polynomial<double>}.
*/
template <class Pol>
- PolynomialSpace(const typename std::vector<Pol> &pols);
+ PolynomialSpace(const std::vector<Pol> &pols);
/**
* Computes the value and the
*/
void compute (const Point<dim> &unit_point,
std::vector<double> &values,
- typename std::vector<Tensor<1,dim> > &grads,
- typename std::vector<Tensor<2,dim> > &grad_grads) const;
+ std::vector<Tensor<1,dim> > &grads,
+ std::vector<Tensor<2,dim> > &grad_grads) const;
/**
* Computes the value of the
template <int dim>
template <class Pol>
PolynomialSpace<dim>::
-PolynomialSpace (const typename std::vector<Pol> &pols)
+PolynomialSpace (const std::vector<Pol> &pols)
:
polynomials (pols.begin(), pols.end()),
n_pols (compute_n_pols(polynomials.size()))
* the weights sum up to one, but
* this is not checked.
*/
- Quadrature (const typename std::vector<Point<dim> > &points,
- const std::vector<double> &weights);
+ Quadrature (const std::vector<Point<dim> > &points,
+ const std::vector<double> &weights);
/**
* Construct a dummy quadrature
* transformed cell in real
* space.
*/
- Quadrature (const typename std::vector<Point<dim> > &points);
+ Quadrature (const std::vector<Point<dim> > &points);
/**
* Constructor for a one-point
* Return a reference to the whole array of
* quadrature points.
*/
- const typename std::vector<Point<dim> > & get_points () const;
+ const std::vector<Point<dim> > & get_points () const;
/**
* Return the weight of the @p{i}th
* List of quadrature points. To be filled
* by the constructors of derived classes.
*/
- typename std::vector<Point<dim> > quadrature_points;
+ std::vector<Point<dim> > quadrature_points;
/**
* List of weights of the quadrature points.
*/
static void project_to_face (const SubQuadrature &quadrature,
const unsigned int face_no,
- typename std::vector<Point<dim> > &q_points);
+ std::vector<Point<dim> > &q_points);
/**
* Compute the quadrature points
static void project_to_subface (const SubQuadrature &quadrature,
const unsigned int face_no,
const unsigned int subface_no,
- typename std::vector<Point<dim> > &q_points);
+ std::vector<Point<dim> > &q_points);
/**
* Take a face quadrature formula
* the right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void value_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<value_type> &values) const;
+ virtual void value_list (const std::vector<Point<dim> > &points,
+ std::vector<value_type> &values) const;
/**
* Return the gradient of the
* the right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<gradient_type> &gradients) const;
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<gradient_type> &gradients) const;
/**
* Exception
* member variable @p{polynomials}.
*/
template <class Pol>
- TensorProductPolynomials(const typename std::vector<Pol> &pols);
+ TensorProductPolynomials(const std::vector<Pol> &pols);
/**
* Computes the value and the
*/
void compute(const Point<dim> &unit_point,
std::vector<double> &values,
- typename std::vector<Tensor<1,dim> > &grads,
- typename std::vector<Tensor<2,dim> > &grad_grads) const;
+ std::vector<Tensor<1,dim> > &grads,
+ std::vector<Tensor<2,dim> > &grad_grads) const;
/**
* Computes the value of the
template <int dim>
template <class Pol>
TensorProductPolynomials<dim>::
-TensorProductPolynomials(const typename std::vector<Pol> &pols)
+TensorProductPolynomials(const std::vector<Pol> &pols)
:
polynomials (pols.begin(), pols.end()),
n_tensor_pols(power(pols.size(), dim)),
* @p{[begin[i],end[i])}.
*/
template <typename ForwardIterator>
- typename std::vector<typename std::pair<ForwardIterator,ForwardIterator> >
+ std::vector<std::pair<ForwardIterator,ForwardIterator> >
split_range (const ForwardIterator &begin,
const ForwardIterator &end,
const unsigned int n_intervals);
template <typename ForwardIterator>
- typename std::vector<typename std::pair<ForwardIterator,ForwardIterator> >
+ std::vector<std::pair<ForwardIterator,ForwardIterator> >
split_range (const ForwardIterator &begin,
const ForwardIterator &end,
const unsigned int n_intervals)
{
- typedef typename std::pair<ForwardIterator,ForwardIterator> IteratorPair;
+ typedef std::pair<ForwardIterator,ForwardIterator> IteratorPair;
// in non-multithreaded mode, we
// often have the case that this
// case efficiently
if (n_intervals==1)
- return (typename std::vector<IteratorPair>
+ return (std::vector<IteratorPair>
(1, IteratorPair(begin, end)));
// if more than one interval
template <int dim>
void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim> &p,
- typename std::vector<Tensor<1,dim> > &gradients) const
+ std::vector<Tensor<1,dim> > &gradients) const
{
Assert (gradients.size() == this->n_components,
ExcDimensionMismatch(gradients.size(), this->n_components));
template <int dim>
-void AutoDerivativeFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+void AutoDerivativeFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int comp) const
{
Assert (gradients.size() == points.size(),
template <int dim>
void
AutoDerivativeFunction<dim>::
-vector_gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const
+vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int dim, int spacedim>
-void DataOutBase::write_ucd (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_ucd (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const UcdFlags &flags,
std::ostream &out)
template <int dim, int spacedim>
-void DataOutBase::write_dx (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_dx (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const DXFlags &flags,
std::ostream &out)
template <int dim, int spacedim>
-void DataOutBase::write_gnuplot (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_gnuplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const GnuplotFlags &/*flags*/,
std::ostream &out)
template <int dim, int spacedim>
-void DataOutBase::write_povray (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_povray (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const PovrayFlags &flags,
std::ostream &out)
template <int dim, int spacedim>
-void DataOutBase::write_eps (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_eps (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &/*data_names*/,
const EpsFlags &flags,
std::ostream &out)
template <int dim, int spacedim>
-void DataOutBase::write_gmv (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_gmv (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const GmvFlags &/*flags*/,
std::ostream &out)
std::vector<std::vector<double> > data_vectors (n_data_sets,
std::vector<double> (n_nodes));
Threads::ThreadManager thread_manager;
- void (*fun_ptr) (const typename std::vector<Patch<dim,spacedim> > &,
+ void (*fun_ptr) (const std::vector<Patch<dim,spacedim> > &,
std::vector<std::vector<double> > &)
= &DataOutBase::template write_gmv_reorder_data_vectors<dim,spacedim>;
Threads::spawn (thread_manager,
template <int dim, int spacedim>
-void DataOutBase::write_tecplot (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_tecplot (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const TecplotFlags &/*flags*/,
std::ostream &out)
std::vector<std::vector<double> > data_vectors (n_data_sets,
std::vector<double> (n_nodes));
Threads::ThreadManager thread_manager;
- void (*fun_ptr) (const typename std::vector<Patch<dim,spacedim> > &,
+ void (*fun_ptr) (const std::vector<Patch<dim,spacedim> > &,
std::vector<std::vector<double> > &)
= &DataOutBase::template write_gmv_reorder_data_vectors<dim,spacedim>;
Threads::spawn (thread_manager,
template <int dim, int spacedim>
-void DataOutBase::write_tecplot_binary (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_tecplot_binary (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const TecplotFlags &flags,
std::ostream &out)
std::vector<std::vector<double> > data_vectors (n_data_sets,
std::vector<double> (n_nodes));
Threads::ThreadManager thread_manager;
- void (*fun_ptr) (const typename std::vector<Patch<dim,spacedim> > &,
+ void (*fun_ptr) (const std::vector<Patch<dim,spacedim> > &,
std::vector<std::vector<double> > &)
= &DataOutBase::template write_gmv_reorder_data_vectors<dim,spacedim>;
Threads::spawn (thread_manager,
template <int dim, int spacedim>
-void DataOutBase::write_vtk (const typename std::vector<Patch<dim,spacedim> > &patches,
+void DataOutBase::write_vtk (const std::vector<Patch<dim,spacedim> > &patches,
const std::vector<std::string> &data_names,
const VtkFlags &/*flags*/,
std::ostream &out)
std::vector<std::vector<double> > data_vectors (n_data_sets,
std::vector<double> (n_nodes));
Threads::ThreadManager thread_manager;
- void (*fun_ptr) (const typename std::vector<Patch<dim,spacedim> > &,
+ void (*fun_ptr) (const std::vector<Patch<dim,spacedim> > &,
std::vector<std::vector<double> > &)
= &DataOutBase::template write_gmv_reorder_data_vectors<dim,spacedim>;
Threads::spawn (thread_manager,
template <int dim, int spacedim>
void
-DataOutBase::write_gmv_reorder_data_vectors (const typename std::vector<Patch<dim,spacedim> > &patches,
+DataOutBase::write_gmv_reorder_data_vectors (const std::vector<Patch<dim,spacedim> > &patches,
std::vector<std::vector<double> > &data_vectors)
{
// unlike in the main function, we
#endif
template <int dim>
-void Function<dim>::value_list (const typename std::vector<Point<dim> > &points,
+void Function<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component) const
{
template <int dim>
-void Function<dim>::vector_value_list (const typename std::vector<Point<dim> > &points,
+void Function<dim>::vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
// check whether component is in
template <int dim>
void Function<dim>::vector_gradient (const Point<dim> &,
- typename std::vector<Tensor<1,dim> > &) const
+ std::vector<Tensor<1,dim> > &) const
{
Assert (false, ExcPureFunctionCalled());
};
template <int dim>
-void Function<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+void Function<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int component) const
{
Assert (gradients.size() == points.size(),
template <int dim>
-void Function<dim>::vector_gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const
+void Function<dim>::vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int dim>
-void Function<dim>::laplacian_list (const typename std::vector<Point<dim> > &points,
+void Function<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &laplacians,
const unsigned int component) const
{
template <int dim>
-void Function<dim>::vector_laplacian_list (const typename std::vector<Point<dim> > &points,
+void Function<dim>::vector_laplacian_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &laplacians) const
{
// check whether component is in
template <int dim>
-void ZeroFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+void ZeroFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int /*component*/) const {
Assert (values.size() == points.size(),
template <int dim>
-void ZeroFunction<dim>::vector_value_list (const typename std::vector<Point<dim> > &points,
+void ZeroFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
template <int dim>
void ZeroFunction<dim>::vector_gradient (const Point<dim> &,
- typename std::vector<Tensor<1,dim> > &gradients) const
+ std::vector<Tensor<1,dim> > &gradients) const
{
Assert (gradients.size() == this->n_components,
ExcDimensionMismatch(gradients.size(), this->n_components));
template <int dim>
-void ZeroFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+void ZeroFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int /*component*/) const
{
Assert (gradients.size() == points.size(),
template <int dim>
-void ZeroFunction<dim>::vector_gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const
+void ZeroFunction<dim>::vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int dim>
-void ConstantFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+void ConstantFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int /*component*/) const
{
template <int dim>
-void ConstantFunction<dim>::vector_value_list (const typename std::vector<Point<dim> > &points,
+void ConstantFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
template <int dim>
-void ComponentSelectFunction<dim>::vector_value_list (const typename std::vector<Point<dim> > &points,
+void ComponentSelectFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
template <int dim>
FunctionDerivative<dim>::FunctionDerivative (const Function<dim>& f,
- const typename std::vector<Point<dim> >& dir,
+ const std::vector<Point<dim> >& dir,
const double h)
:
Function<dim> (f.n_components, f.get_time()),
template <int dim>
void
-FunctionDerivative<dim>::value_list (const typename std::vector<Point<dim> > &points,
+FunctionDerivative<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component) const
{
template<int dim>
void
- SquareFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+ SquareFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- SquareFunction<dim>::laplacian_list (const typename std::vector<Point<dim> > &points,
+ SquareFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- SquareFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ SquareFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
- Q1WedgeFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+ Q1WedgeFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- Q1WedgeFunction<dim>::laplacian_list (const typename std::vector<Point<dim> > &points,
+ Q1WedgeFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- Q1WedgeFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ Q1WedgeFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
- PillowFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+ PillowFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- PillowFunction<dim>::laplacian_list (const typename std::vector<Point<dim> > &points,
+ PillowFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- PillowFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ PillowFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
- CosineFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+ CosineFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- CosineFunction<dim>::laplacian_list (const typename std::vector<Point<dim> > &points,
+ CosineFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- CosineFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ CosineFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
- CosineFunction<dim>::hessian_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<2,dim> > &hessians,
+ CosineFunction<dim>::hessian_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<2,dim> > &hessians,
const unsigned int) const
{
Assert (hessians.size() == points.size(),
template<int dim>
void
- ExpFunction<dim>::value_list (const typename std::vector<Point<dim> > &points,
+ ExpFunction<dim>::value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- ExpFunction<dim>::laplacian_list (const typename std::vector<Point<dim> > &points,
+ ExpFunction<dim>::laplacian_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- ExpFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<Tensor<1,dim> > &gradients,
+ ExpFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
- JumpFunction<dim>::value_list (const typename std::vector<Point<dim> > &p,
+ JumpFunction<dim>::value_list (const std::vector<Point<dim> > &p,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- JumpFunction<dim>::laplacian_list (const typename std::vector<Point<dim> > &p,
+ JumpFunction<dim>::laplacian_list (const std::vector<Point<dim> > &p,
std::vector<double> &values,
const unsigned int) const
{
template<int dim>
void
- JumpFunction<dim>::gradient_list (const typename std::vector<Point<dim> > &p,
- typename std::vector<Tensor<1,dim> > &gradients,
+ JumpFunction<dim>::gradient_list (const std::vector<Point<dim> > &p,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == p.size(),
template <int dim>
FourierSineSum<dim>::
- FourierSineSum (const typename std::vector<Point<dim> > &fourier_coefficients,
+ FourierSineSum (const std::vector<Point<dim> > &fourier_coefficients,
const std::vector<double> &weights)
:
Function<dim> (1),
template <int dim>
FourierCosineSum<dim>::
- FourierCosineSum (const typename std::vector<Point<dim> > &fourier_coefficients,
+ FourierCosineSum (const std::vector<Point<dim> > &fourier_coefficients,
const std::vector<double> &weights)
:
Function<dim> (1),
template<int dim>
void
- CutOffFunctionLinfty<dim>::value_list (const typename std::vector<Point<dim> > &points,
- std::vector<double> &values,
+ CutOffFunctionLinfty<dim>::value_list (const std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert (values.size() == points.size(),
template<int dim>
void
CutOffFunctionLinfty<dim>::vector_value_list (
- const typename std::vector<Point<dim> > &points,
+ const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
template<int dim>
void
- CutOffFunctionW1<dim>::value_list (const typename std::vector<Point<dim> > &points,
- std::vector<double> &values,
+ CutOffFunctionW1<dim>::value_list (const std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert (values.size() == points.size(),
template<int dim>
void
CutOffFunctionW1<dim>::vector_value_list (
- const typename std::vector<Point<dim> > &points,
+ const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
template<int dim>
void
- CutOffFunctionCinfty<dim>::value_list (const typename std::vector<Point<dim> > &points,
- std::vector<double> &values,
+ CutOffFunctionCinfty<dim>::value_list (const std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int component) const
{
Assert (values.size() == points.size(),
template<int dim>
void
CutOffFunctionCinfty<dim>::vector_value_list (
- const typename std::vector<Point<dim> > &points,
+ const std::vector<Point<dim> > &points,
std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
// Reserve space for polynomials up to degree 19. Should be sufficient
// for the start.
template <typename number>
-typename std::vector<const typename std::vector<number> *>
+std::vector<const std::vector<number> *>
Legendre<number>::recursive_coefficients(
- 20, static_cast<const typename std::vector<number>*>(0));
+ 20, static_cast<const std::vector<number>*>(0));
template <typename number>
-typename std::vector<const typename std::vector<number> *>
+std::vector<const std::vector<number> *>
Legendre<number>::shifted_coefficients(
- 20, static_cast<const typename std::vector<number>*>(0));
+ 20, static_cast<const std::vector<number>*>(0));
// have a lock that guarantees that at most one thread is changing and
template <typename number>
-const typename std::vector<number> &
+const std::vector<number> &
Legendre<number>::get_coefficients (const unsigned int k)
{
// first make sure the coefficients
#include <base/exceptions.h>
template <typename number>
-Polynomial<number>::Polynomial (const typename std::vector<number> &a):
+Polynomial<number>::Polynomial (const std::vector<number> &a):
coefficients(a)
{}
template <typename number>
void
Polynomial<number>::value (const number x,
- typename std::vector<number> &values) const
+ std::vector<number> &values) const
{
Assert (coefficients.size() > 0, ExcVoidPolynomial());
Assert (values.size() > 0, ExcEmptyArray());
template <typename number>
void
-Polynomial<number>::scale(typename std::vector<number>& coefficients,
+Polynomial<number>::scale(std::vector<number>& coefficients,
const number factor)
{
double f = 1.;
template <typename number>
void
-Polynomial<number>::multiply(typename std::vector<number>& coefficients,
+Polynomial<number>::multiply(std::vector<number>& coefficients,
const number factor)
{
for (typename std::vector<number>::iterator c = coefficients.begin();
template <typename number>
template <typename number2>
void
-Polynomial<number>::shift(typename std::vector<number>& coefficients,
+Polynomial<number>::shift(std::vector<number>& coefficients,
const number2 offset)
{
#ifdef DEAL_II_LONG_DOUBLE_LOOP_BUG
void PolynomialSpace<dim>::compute(
const Point<dim> &p,
std::vector<double> &values,
- typename std::vector<Tensor<1,dim> > &grads,
- typename std::vector<Tensor<2,dim> > &grad_grads) const
+ std::vector<Tensor<1,dim> > &grads,
+ std::vector<Tensor<2,dim> > &grad_grads) const
{
const unsigned int n_1d=polynomials.size();
template <int dim>
-Quadrature<dim>::Quadrature (const typename std::vector<Point<dim> > &points,
+Quadrature<dim>::Quadrature (const std::vector<Point<dim> > &points,
const std::vector<double> &weights)
:
n_quadrature_points(points.size()),
template <int dim>
-Quadrature<dim>::Quadrature (const typename std::vector<Point<dim> > &points)
+Quadrature<dim>::Quadrature (const std::vector<Point<dim> > &points)
:
n_quadrature_points(points.size()),
quadrature_points(points),
template <int dim>
-const typename std::vector<Point<dim> > & Quadrature<dim>::get_points () const
+const std::vector<Point<dim> > & Quadrature<dim>::get_points () const
{
return quadrature_points;
};
n_faces = GeometryInfo<dim>::faces_per_cell;
// first fix quadrature points
- typename std::vector<Point<dim> > q_points (n_points * n_faces);
+ std::vector<Point<dim> > q_points (n_points * n_faces);
std::vector <Point<dim> > help(n_points);
// project to each face and copy
}
// next copy over weights
- typename std::vector<double> weights (n_points * n_faces);
+ std::vector<double> weights (n_points * n_faces);
for (unsigned int face=0; face<n_faces; ++face)
std::copy (quadrature.get_weights().begin(),
quadrature.get_weights().end(),
subfaces_per_face = GeometryInfo<dim>::subfaces_per_face;
// first fix quadrature points
- typename std::vector<Point<dim> > q_points (n_points * n_faces * subfaces_per_face);
+ std::vector<Point<dim> > q_points (n_points * n_faces * subfaces_per_face);
std::vector <Point<dim> > help(n_points);
// project to each face and copy
};
// next copy over weights
- typename std::vector<double> weights (n_points * n_faces * subfaces_per_face);
+ std::vector<double> weights (n_points * n_faces * subfaces_per_face);
for (unsigned int face=0; face<n_faces; ++face)
for (unsigned int subface=0; subface<subfaces_per_face; ++subface)
std::copy (quadrature.get_weights().begin(),
template <int rank, int dim>
void
-TensorFunction<rank, dim>::value_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<value_type> &values) const
+TensorFunction<rank, dim>::value_list (const std::vector<Point<dim> > &points,
+ std::vector<value_type> &values) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int rank, int dim>
void
-TensorFunction<rank, dim>::gradient_list (const typename std::vector<Point<dim> > &points,
- typename std::vector<gradient_type> &gradients) const
+TensorFunction<rank, dim>::gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<gradient_type> &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
void TensorProductPolynomials<dim>::compute(
const Point<dim> &p,
std::vector<double> &values,
- typename std::vector<Tensor<1,dim> > &grads,
- typename std::vector<Tensor<2,dim> > &grad_grads) const
+ std::vector<Tensor<1,dim> > &grads,
+ std::vector<Tensor<2,dim> > &grad_grads) const
{
const unsigned int n_pols=polynomials.size();
* @p{levels[]} tree of the @ref{Triangulation}
* objects.
*/
- typename std::vector<DoFLevel<dim>*> levels;
+ std::vector<DoFLevel<dim>*> levels;
/**
* Store the number of dofs created last
static void
map_dofs_to_support_points (const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
- typename std::vector<Point<dim> > &support_points);
+ std::vector<Point<dim> > &support_points);
/**
* This is the opposite function
static void
map_support_points_to_dofs (const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
- typename std::map<Point<dim>, unsigned int, Comp> &point_to_index_map);
+ std::map<Point<dim>, unsigned int, Comp> &point_to_index_map);
/**
* Exception
DoFTools::
map_support_points_to_dofs (const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
- typename std::map<Point<dim>, unsigned int, Comp> &point_to_index_map)
+ std::map<Point<dim>, unsigned int, Comp> &point_to_index_map)
{
// let the checking of arguments be
// done by the function first
* name it in the fashion of the
* STL local typedefs.
*/
- typedef typename std::map<unsigned char, const Function<dim>*> type;
+ typedef std::map<unsigned char, const Function<dim>*> type;
};
* entries in lower dimensions
* are missing.
*/
- typename std::vector<FEValues<dim>*> differences;
+ std::vector<FEValues<dim>*> differences;
};
/**
* See the class documentation
* for details on support points.
*/
- const typename std::vector<Point<dim> > &
+ const std::vector<Point<dim> > &
get_unit_support_points () const;
/**
* See the class documentation
* for details on support points.
*/
- const typename std::vector<Point<dim-1> > &
+ const std::vector<Point<dim-1> > &
get_unit_face_support_points () const;
/**
* support points. In that case,
* this field remains empty.
*/
- typename std::vector<Point<dim> > unit_support_points;
+ std::vector<Point<dim> > unit_support_points;
/**
* Same for the faces. See the
* what contributes a face
* support point.
*/
- typename std::vector<Point<dim-1> > unit_face_support_points;
+ std::vector<Point<dim-1> > unit_face_support_points;
/**
* For each shape function, give
* multiplication) when
* visiting an actual cell.
*/
- typename std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
+ std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
};
/**
* multiplication) when
* visiting an actual cell.
*/
- typename std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
+ std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
};
/**
* multiplication) when
* visiting an actual cell.
*/
- typename std::vector<typename std::vector<Tensor<2,dim> > > shape_gradients;
+ std::vector<std::vector<Tensor<2,dim> > > shape_gradients;
};
/**
* multiplication) when
* visiting an actual cell.
*/
- typename std::vector<typename std::vector<Tensor<1,dim> > > shape_gradients;
+ std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
};
/**
* Pairs of multiplicity and
* element type.
*/
- typedef typename std::pair<const FiniteElement<dim> *, unsigned int> ElementPair;
+ typedef std::pair<const FiniteElement<dim> *, unsigned int> ElementPair;
/**
* Pointer to underlying finite
* created by the constructor and
* constant afterwards.
*/
- typename std::vector<ElementPair> base_elements;
+ std::vector<ElementPair> base_elements;
/**
* by the InternalData
* constructor.
*/
- typename std::vector<FEValuesData<dim> *> base_fe_values_datas;
+ std::vector<FEValuesData<dim> *> base_fe_values_datas;
};
};
* @ref{ShapeVector} data type.
*/
typedef
- typename std::vector<typename std::vector<Tensor<1,dim> > >
+ std::vector<std::vector<Tensor<1,dim> > >
GradientVector;
/**
* derivatives.
*/
typedef
- typename std::vector<typename std::vector<Tensor<2,dim> > >
+ std::vector<std::vector<Tensor<2,dim> > >
GradGradVector;
/**
* real element, rather than on the
* reference element.
*/
- typename std::vector<Point<dim> > quadrature_points;
+ std::vector<Point<dim> > quadrature_points;
/**
* List of outward normal vectors at the
* quadrature points. This field is filled
* in by the finite element class.
*/
- typename std::vector<Point<dim> > normal_vectors;
+ std::vector<Point<dim> > normal_vectors;
/**
* List of boundary forms at the
* quadrature points. This field is filled
* in by the finite element class.
*/
- typename std::vector<Tensor<1,dim> > boundary_forms;
+ std::vector<Tensor<1,dim> > boundary_forms;
/**
* Indicate the first row which a
*/
template <class InputVector, typename number>
void get_function_values (const InputVector& fe_function,
- typename std::vector<number>& values) const;
+ std::vector<number>& values) const;
/**
* Access to vector valued finite
*/
template <class InputVector, typename number>
void get_function_values (const InputVector &fe_function,
- typename std::vector<Vector<number> > &values) const;
+ std::vector<Vector<number> > &values) const;
/**
* Gradient of the @p{i}th shape
*/
template <class InputVector>
void get_function_grads (const InputVector &fe_function,
- typename std::vector<Tensor<1,dim> > &gradients) const;
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Return the gradients of the finite
*/
template <class InputVector>
void get_function_grads (const InputVector &fe_function,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const;
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
/**
* 2nd derivatives of
*/
template <class InputVector>
void get_function_2nd_derivatives (const InputVector& fe_function,
- typename std::vector<Tensor<2,dim> >& second_derivatives) const;
+ std::vector<Tensor<2,dim> >& second_derivatives) const;
/**
*/
template <class InputVector>
void get_function_2nd_derivatives (const InputVector &fe_function,
- typename std::vector<typename std::vector<Tensor<2,dim> > > &second_derivatives) const;
+ std::vector<std::vector<Tensor<2,dim> > > &second_derivatives) const;
/**
* Position of the @p{i}th
* Return a pointer to the vector of
* quadrature points.
*/
- const typename std::vector<Point<dim> > & get_quadrature_points () const;
+ const std::vector<Point<dim> > & get_quadrature_points () const;
/**
* Mapped quadrature weight. This
* vectors to the cell at the
* quadrature points.
*/
- const typename std::vector<Point<dim> > & get_normal_vectors () const;
+ const std::vector<Point<dim> > & get_normal_vectors () const;
/**
* Return the list of outward normal
* vectors times quadrature weights.
*/
- const typename std::vector<Tensor<1,dim> > & get_boundary_forms () const;
+ const std::vector<Tensor<1,dim> > & get_boundary_forms () const;
/**
* Return the present
fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
const Quadrature<dim> &quadrature,
InternalDataBase &internal,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values) const = 0;
/**
const unsigned int face_no,
const Quadrature<dim-1> &quadrature,
InternalDataBase &internal,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const = 0;
+ std::vector<Tensor<1,dim> > &boundary_form,
+ std::vector<Point<dim> > &normal_vectors) const = 0;
/**
* See above.
const unsigned int sub_no,
const Quadrature<dim-1> &quadrature,
InternalDataBase &internal,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const = 0;
+ std::vector<Tensor<1,dim> > &boundary_form,
+ std::vector<Point<dim> > &normal_vectors) const = 0;
/**
* Give class @p{FEValues} access
*/
virtual void
add_line_support_points (const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* For @p{dim=3}. Append the
*/
virtual void
add_quad_support_points(const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
};
fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
const Quadrature<dim>& quadrature,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values) const ;
/**
const unsigned int face_no,
const Quadrature<dim-1>& quadrature,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const ;
+ std::vector<Tensor<1,dim> > &boundary_form,
+ std::vector<Point<dim> > &normal_vectors) const ;
/**
* Implementation of the interface in
const unsigned int sub_no,
const Quadrature<dim-1>& quadrature,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const ;
+ std::vector<Tensor<1,dim> > &boundary_form,
+ std::vector<Point<dim> > &normal_vectors) const ;
/**
*/
virtual void
transform_contravariant (typename std::vector<Tensor<1,dim> >::iterator begin,
- typename std::vector<Tensor<1,dim> >::const_iterator end,
- typename std::vector<Tensor<1,dim> >::const_iterator src,
- const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+ typename std::vector<Tensor<1,dim> >::const_iterator end,
+ typename std::vector<Tensor<1,dim> >::const_iterator src,
+ const typename Mapping<dim>::InternalDataBase &mapping_data) const;
/**
* Transforms the point @p{p} on
DeclException0 (ExcInvalidData);
protected:
-
/**
* Storage for internal data of
* d-linear transformation.
* points. Especially, all
* points of all faces.
*/
- typename std::vector<Point<dim> > quadrature_points;
+ std::vector<Point<dim> > quadrature_points;
/**
* Unit tangential vectors. Used
*
* Filled once.
*/
- typename std::vector<typename std::vector<Tensor<1,dim> > > unit_tangentials;
+ std::vector<std::vector<Tensor<1,dim> > > unit_tangentials;
/**
* Auxiliary vectors for internal use.
*/
- typename std::vector<typename std::vector<Tensor<1,dim> > > aux;
+ std::vector<std::vector<Tensor<1,dim> > > aux;
};
/**
const unsigned int face_no,
const unsigned int sub_no,
InternalData& data,
- typename std::vector<Point<dim> > &quadrature_points,
- typename std::vector<Point<dim> >& normal_vectors) const;
+ std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> >& normal_vectors) const;
private:
/**
*/
virtual void
transform_contravariant (typename std::vector<Tensor<1,dim> >::iterator begin,
- typename std::vector<Tensor<1,dim> >::const_iterator end,
- typename std::vector<Tensor<1,dim> >::const_iterator src,
- const typename Mapping<dim>::InternalDataBase &mapping_data) const;
+ typename std::vector<Tensor<1,dim> >::const_iterator end,
+ typename std::vector<Tensor<1,dim> >::const_iterator src,
+ const typename Mapping<dim>::InternalDataBase &mapping_data) const;
/**
* Return the degree of the
* Filled (hardcoded) once in
* @p{get_face_data}.
*/
- typename std::vector<typename std::vector<Point<dim> > > unit_normals;
+ std::vector<std::vector<Point<dim> > > unit_normals;
/**
* Flag that is set by the
*/
virtual void
add_line_support_points (const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* For @p{dim=3}. Append the
*/
virtual void
add_quad_support_points(const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
private:
* derivatives.
*/
virtual void
- compute_shapes_virtual (const typename std::vector<Point<dim> > &unit_points,
+ compute_shapes_virtual (const std::vector<Point<dim> > &unit_points,
typename MappingQ1<dim>::InternalData &data) const;
/**
* points are appended.
*/
void apply_laplace_vector(const std::vector<std::vector<double> > &lvs,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* Computes the support points of
*/
virtual void compute_mapping_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* Computes all support points of
*/
void compute_support_points_laplace(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* Simple version of the
*/
void compute_support_points_simple(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* For @p{dim=2} and 3. Simple
*/
//TODO:[RH] (later) remove this function altogether?
void fill_quad_support_points_simple (const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* Needed by the
*
* Computed once.
*/
- typename std::vector<Tensor<1,dim> > shape_derivatives;
+ std::vector<Tensor<1,dim> > shape_derivatives;
/**
* Tensors of covariant
*
* Computed on each cell.
*/
- typename std::vector<Tensor<2,dim> > covariant;
+ std::vector<Tensor<2,dim> > covariant;
/**
* Tensors of covariant
*
* Computed on each cell.
*/
- typename std::vector<Tensor<2,dim> > contravariant;
+ std::vector<Tensor<2,dim> > contravariant;
/**
* Unit tangential vectors. Used
*
* Filled once.
*/
- typename std::vector<typename std::vector<Tensor<1,dim> > > unit_tangentials;
+ std::vector<std::vector<Tensor<1,dim> > > unit_tangentials;
/**
* Auxuliary vectors for internal use.
*/
- typename std::vector<typename std::vector<Tensor<1,dim> > > aux;
+ std::vector<std::vector<Tensor<1,dim> > > aux;
/**
* Stores the support points of
* the mapping shape functions on
* the @p{cell_of_current_support_points}.
*/
- typename std::vector<Point<dim> > mapping_support_points;
+ std::vector<Point<dim> > mapping_support_points;
/**
* Stores the cell of which the
* @p{data.is_mapping_q1_data}
* equals @p{true} or @p{false}.
*/
- void compute_shapes (const typename std::vector<Point<dim> > &unit_points,
+ void compute_shapes (const std::vector<Point<dim> > &unit_points,
InternalData &data) const;
/**
const unsigned int npts,
const unsigned int offset,
InternalData &data,
- typename std::vector<Point<dim> > &quadrature_points) const;
+ std::vector<Point<dim> > &quadrature_points) const;
/**
* Do the computation for the
const unsigned int offset,
const std::vector<double> &weights,
InternalData &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_form,
- typename std::vector<Point<dim> > &normal_vectors) const;
+ std::vector<Tensor<1,dim> > &boundary_form,
+ std::vector<Point<dim> > &normal_vectors) const;
/**
* Compute shape values and/or
* derivatives.
*/
- virtual void compute_shapes_virtual (const typename std::vector<Point<dim> > &unit_points,
+ virtual void compute_shapes_virtual (const std::vector<Point<dim> > &unit_points,
InternalData &data) const;
/**
*/
virtual void compute_mapping_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
/**
* Number of shape functions. Is
*/
virtual void compute_mapping_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const;
+ std::vector<Point<dim> > &a) const;
};
*/
template <int dim>
static void laplace_transformation (Triangulation<dim> &tria,
- const typename std::map<unsigned int,Point<dim> > &new_points);
+ const std::map<unsigned int,Point<dim> > &new_points);
/**
* Declaration of same function
* have to eliminate unused
* vertices beforehand.
*/
- static void delete_unused_vertices (typename std::vector<Point<dim> > &vertices,
- typename std::vector<CellData<dim> > &cells,
+ static void delete_unused_vertices (std::vector<Point<dim> > &vertices,
+ std::vector<CellData<dim> > &cells,
SubCellData &subcelldata);
/**
* without further ado by the
* user.
*/
- static void debug_output_grid (const typename std::vector<CellData<dim> > &cells,
- const typename std::vector<Point<dim> > &vertices,
+ static void debug_output_grid (const std::vector<CellData<dim> > &cells,
+ const std::vector<Point<dim> > &vertices,
std::ostream &out);
};
* general documentation of this
* class.
*/
- static void reorder_cells (typename std::vector<CellData<dim> > &original_cells);
+ static void reorder_cells (std::vector<CellData<dim> > &original_cells);
private:
* @p{adjacent_cells} field
* of the inserted faces.
*/
- void insert_faces (typename std::map<Face,FaceData > &global_faces);
+ void insert_faces (std::map<Face,FaceData > &global_faces);
/**
* Find out the neighbors of the
* as recursive calls but rather
* as eliminated tail-recursion.
*/
- static void track_back (typename std::vector<Cell> &cells,
+ static void track_back (std::vector<Cell> &cells,
RotationStack &rotation_states,
const unsigned int track_back_to_cell);
- static bool try_rotate_single_neighbors (typename std::vector<Cell> &cells,
+ static bool try_rotate_single_neighbors (std::vector<Cell> &cells,
RotationStack &rotation_states);
/**
* between original cells and
* presorted cells.
*/
- static void find_reordering (typename std::vector<Cell> &cells,
- typename std::vector<CellData<dim> > &original_cells,
+ static void find_reordering (std::vector<Cell> &cells,
+ std::vector<CellData<dim> > &original_cells,
const std::vector<unsigned int> &new_cell_numbers);
/**
*/
static
std::vector<unsigned int>
- presort_cells (typename std::vector<Cell> &cells,
- typename std::map<Face,FaceData> &faces);
+ presort_cells (std::vector<Cell> &cells,
+ std::map<Face,FaceData> &faces);
/**
* By the resolution of Defect
* The actual data. Hold one iterator
* for each cell on each level.
*/
- typename std::vector<typename std::vector<cell_iterator> > mapping;
+ std::vector<std::vector<cell_iterator> > mapping;
/**
* Store a pointer to the source grid.
* is not useful in the context of this
* class.
*/
- virtual void create_triangulation (const typename std::vector<Point<dim> > &vertices,
- const typename std::vector<CellData<dim> > &cells,
+ virtual void create_triangulation (const std::vector<Point<dim> > &vertices,
+ const std::vector<CellData<dim> > &cells,
const SubCellData &subcelldata);
/**
* and the @ref{GridIn} and
* @ref{GridReordering} class.
*/
- virtual void create_triangulation (const typename std::vector<Point<dim> > &vertices,
- const typename std::vector<CellData<dim> > &cells,
+ virtual void create_triangulation (const std::vector<Point<dim> > &vertices,
+ const std::vector<CellData<dim> > &cells,
const SubCellData &subcelldata);
/**
* function
* @ref{get_used_vertices}.
*/
- const typename std::vector<Point<dim> > &
+ const std::vector<Point<dim> > &
get_vertices () const;
/**
*
* Usage is like @p{levels[3]->quads}.
*/
- typename std::vector<TriangulationLevel<dim>*> levels;
+ std::vector<TriangulationLevel<dim>*> levels;
/**
* Array of the vertices of this
* triangulation.
*/
- typename std::vector<Point<dim> > vertices;
+ std::vector<Point<dim> > vertices;
/**
* Array storing a bit-pattern which
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Return equally spaced
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Compute the normal vectors to
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Gives @p{n=points.size()=m*m}
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Compute the normals to the
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Refer to the general
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Compute the normals to the
* base class.
*/
void get_intermediate_points_between_points (const Point<dim> &p0, const Point<dim> &p1,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
};
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Refer to the general
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Compute the normals to the
* base class.
*/
void get_intermediate_points_between_points (const Point<dim> &p0, const Point<dim> &p1,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
};
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Refer to the general
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Compute the normals to the
*/
virtual void
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Refer to the general
*/
virtual void
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const;
+ std::vector<Point<dim> > &points) const;
/**
* Compute the normals to the
/**
* Array of the objects to be held.
*/
- typename std::vector<Object> objects;
+ std::vector<Object> objects;
};
* are numbers which start from
* zero on each level.
*/
- typename std::vector<DoFLevel<dim>*> mg_levels;
+ std::vector<DoFLevel<dim>*> mg_levels;
/**
* For each vertex there is a
* different levels it lives on
* and which are these levels.
*/
- typename std::vector<MGVertexDoFs> mg_vertex_dofs;
+ std::vector<MGVertexDoFs> mg_vertex_dofs;
/**
* Vectors storing the number of
* List of data elements with vectors of
* values for each degree of freedom.
*/
- typename std::vector<DataEntry> dof_data;
+ std::vector<DataEntry> dof_data;
/**
* List of data elements with vectors of
* values for each cell.
*/
- typename std::vector<DataEntry> cell_data;
+ std::vector<DataEntry> cell_data;
/**
* This is a list of patches that is
* in the output routines of the base
* classes.
*/
- typename std::vector<Patch> patches;
+ std::vector<Patch> patches;
/**
* Function by which the base
* what patches they shall write
* to a file.
*/
- virtual const typename std::vector<Patch> &
+ virtual const std::vector<Patch> &
get_patches () const;
/**
* List of patches of all past and
* present parameter value data sets.
*/
- typename std::vector< ::DataOutBase::Patch<dim+1> > patches;
+ std::vector< ::DataOutBase::Patch<dim+1> > patches;
/**
* Structure holding data vectors
/**
* List of DoF data vectors.
*/
- typename std::vector<DataVector> dof_data;
+ std::vector<DataVector> dof_data;
/**
* List of cell data vectors.
*/
- typename std::vector<DataVector> cell_data;
+ std::vector<DataVector> cell_data;
/**
* This is the function through
* the base class @ref{DataOutBase}) to
* the actual output function.
*/
- virtual const typename std::vector< ::DataOutBase::Patch<dim+1> > & get_patches () const;
+ virtual const std::vector< ::DataOutBase::Patch<dim+1> > & get_patches () const;
/**
* index of the solution
* vector.
*/
- typename std::vector<typename std::vector<typename std::vector<Tensor<1,dim> > > > psi;
+ std::vector<std::vector<std::vector<Tensor<1,dim> > > > psi;
/**
* The same vector for a neighbor cell
*/
- typename std::vector<typename std::vector<typename std::vector<Tensor<1,dim> > > > neighbor_psi;
+ std::vector<std::vector<std::vector<Tensor<1,dim> > > > neighbor_psi;
/**
* The normal vectors of the finite
* element function on one face
*/
- typename std::vector<Point<dim> > normal_vectors;
+ std::vector<Point<dim> > normal_vectors;
/**
* Two arrays needed for the
* on this.
*/
template <typename number>
- void evaluate (const typename std::vector<Vector<number> > &values,
+ void evaluate (const std::vector<Vector<number> > &values,
const std::vector<double> &y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing = linear);
* Abbreviation for a pair of
* iterators.
*/
- typedef typename std::pair<active_cell_iterator,active_cell_iterator> iterator_pair;
+ typedef std::pair<active_cell_iterator,active_cell_iterator> iterator_pair;
/**
* Constructor. Initialize
* onto the new (refined and/or
* coarsenend) grid.
*/
- void prepare_for_coarsening_and_refinement (const typename std::vector<Vector<number> > &all_in);
+ void prepare_for_coarsening_and_refinement (const std::vector<Vector<number> > &all_in);
/**
* Same as previous function
* several functions can be
* performed in one step.
*/
- void interpolate (const typename std::vector<Vector<number> >&all_in,
- typename std::vector<Vector<number> > &all_out) const;
+ void interpolate (const std::vector<Vector<number> >&all_in,
+ std::vector<Vector<number> > &all_out) const;
/**
* Same as the previous function.
unsigned int memory_consumption () const;
std::vector<unsigned int> *indices_ptr;
- typename std::vector<Vector<number> > *dof_values_ptr;
+ std::vector<Vector<number> > *dof_values_ptr;
};
/**
* collecting all these structures in a vector
* helps avoiding fraqmentation of the memory.
*/
- typename std::vector<Pointerstruct> all_pointerstructs;
+ std::vector<Pointerstruct> all_pointerstructs;
/**
* Is used for
* of all cells that'll be coarsened
* will be stored in this vector.
*/
- typename std::vector<typename std::vector<Vector<number> > > dof_values_on_cell;
+ std::vector<std::vector<Vector<number> > > dof_values_on_cell;
};
void
DoFTools::map_dofs_to_support_points (const Mapping<dim> &mapping,
const DoFHandler<dim> &dof_handler,
- typename std::vector<Point<dim> > &support_points)
+ std::vector<Point<dim> > &support_points)
{
const unsigned int dofs_per_cell = dof_handler.get_fe().dofs_per_cell;
template <int dim>
-const typename std::vector<Point<dim> > &
+const std::vector<Point<dim> > &
FiniteElementBase<dim>::get_unit_support_points () const
{
// a finite element may define
template <int dim>
-const typename std::vector<Point<dim-1> > &
+const std::vector<Point<dim-1> > &
FiniteElementBase<dim>::get_unit_face_support_points () const
{
// a finite element may define
FE_DGP<1>::Matrices::embedding[][GeometryInfo<1>::children_per_cell] =
{
{FE_DGP_1d::dgp0_into_dgp0_refined_0, FE_DGP_1d::dgp0_into_dgp0_refined_1},
- {FE_DGP_1d::dgp1_into_dgp1_refined_0, FE_DGP_1d::dgp1_into_dgp1_refined_1},
- {FE_DGP_1d::dgp2_into_dgp2_refined_0, FE_DGP_1d::dgp2_into_dgp2_refined_1},
- {FE_DGP_1d::dgp3_into_dgp3_refined_0, FE_DGP_1d::dgp3_into_dgp3_refined_1},
- {FE_DGP_1d::dgp4_into_dgp4_refined_0, FE_DGP_1d::dgp4_into_dgp4_refined_1},
- {FE_DGP_1d::dgp5_into_dgp5_refined_0, FE_DGP_1d::dgp5_into_dgp5_refined_1},
- {FE_DGP_1d::dgp6_into_dgp6_refined_0, FE_DGP_1d::dgp6_into_dgp6_refined_1}
+ {FE_DGP_1d::dgp1_into_dgp1_refined_0, FE_DGP_1d::dgp1_into_dgp1_refined_1},
+ {FE_DGP_1d::dgp2_into_dgp2_refined_0, FE_DGP_1d::dgp2_into_dgp2_refined_1},
+ {FE_DGP_1d::dgp3_into_dgp3_refined_0, FE_DGP_1d::dgp3_into_dgp3_refined_1},
+ {FE_DGP_1d::dgp4_into_dgp4_refined_0, FE_DGP_1d::dgp4_into_dgp4_refined_1},
+ {FE_DGP_1d::dgp5_into_dgp5_refined_0, FE_DGP_1d::dgp5_into_dgp5_refined_1},
+ {FE_DGP_1d::dgp6_into_dgp6_refined_0, FE_DGP_1d::dgp6_into_dgp6_refined_1}
};
template <>
FE_DGP<2>::Matrices::embedding[][GeometryInfo<2>::children_per_cell] =
{
{ FE_DGP_2d::dgp0_into_dgp0_refined_0,
- FE_DGP_2d::dgp0_into_dgp0_refined_1,
- FE_DGP_2d::dgp0_into_dgp0_refined_2,
- FE_DGP_2d::dgp0_into_dgp0_refined_3 },
- { FE_DGP_2d::dgp1_into_dgp1_refined_0,
- FE_DGP_2d::dgp1_into_dgp1_refined_1,
- FE_DGP_2d::dgp1_into_dgp1_refined_2,
- FE_DGP_2d::dgp1_into_dgp1_refined_3 },
- { FE_DGP_2d::dgp2_into_dgp2_refined_0,
- FE_DGP_2d::dgp2_into_dgp2_refined_1,
- FE_DGP_2d::dgp2_into_dgp2_refined_2,
- FE_DGP_2d::dgp2_into_dgp2_refined_3 },
- { FE_DGP_2d::dgp3_into_dgp3_refined_0,
- FE_DGP_2d::dgp3_into_dgp3_refined_1,
- FE_DGP_2d::dgp3_into_dgp3_refined_2,
- FE_DGP_2d::dgp3_into_dgp3_refined_3 },
- { FE_DGP_2d::dgp4_into_dgp4_refined_0,
- FE_DGP_2d::dgp4_into_dgp4_refined_1,
- FE_DGP_2d::dgp4_into_dgp4_refined_2,
- FE_DGP_2d::dgp4_into_dgp4_refined_3 },
- { FE_DGP_2d::dgp5_into_dgp5_refined_0,
- FE_DGP_2d::dgp5_into_dgp5_refined_1,
- FE_DGP_2d::dgp5_into_dgp5_refined_2,
- FE_DGP_2d::dgp5_into_dgp5_refined_3 },
- { FE_DGP_2d::dgp6_into_dgp6_refined_0,
- FE_DGP_2d::dgp6_into_dgp6_refined_1,
- FE_DGP_2d::dgp6_into_dgp6_refined_2,
- FE_DGP_2d::dgp6_into_dgp6_refined_3 }
+ FE_DGP_2d::dgp0_into_dgp0_refined_1,
+ FE_DGP_2d::dgp0_into_dgp0_refined_2,
+ FE_DGP_2d::dgp0_into_dgp0_refined_3 },
+ { FE_DGP_2d::dgp1_into_dgp1_refined_0,
+ FE_DGP_2d::dgp1_into_dgp1_refined_1,
+ FE_DGP_2d::dgp1_into_dgp1_refined_2,
+ FE_DGP_2d::dgp1_into_dgp1_refined_3 },
+ { FE_DGP_2d::dgp2_into_dgp2_refined_0,
+ FE_DGP_2d::dgp2_into_dgp2_refined_1,
+ FE_DGP_2d::dgp2_into_dgp2_refined_2,
+ FE_DGP_2d::dgp2_into_dgp2_refined_3 },
+ { FE_DGP_2d::dgp3_into_dgp3_refined_0,
+ FE_DGP_2d::dgp3_into_dgp3_refined_1,
+ FE_DGP_2d::dgp3_into_dgp3_refined_2,
+ FE_DGP_2d::dgp3_into_dgp3_refined_3 },
+ { FE_DGP_2d::dgp4_into_dgp4_refined_0,
+ FE_DGP_2d::dgp4_into_dgp4_refined_1,
+ FE_DGP_2d::dgp4_into_dgp4_refined_2,
+ FE_DGP_2d::dgp4_into_dgp4_refined_3 },
+ { FE_DGP_2d::dgp5_into_dgp5_refined_0,
+ FE_DGP_2d::dgp5_into_dgp5_refined_1,
+ FE_DGP_2d::dgp5_into_dgp5_refined_2,
+ FE_DGP_2d::dgp5_into_dgp5_refined_3 },
+ { FE_DGP_2d::dgp6_into_dgp6_refined_0,
+ FE_DGP_2d::dgp6_into_dgp6_refined_1,
+ FE_DGP_2d::dgp6_into_dgp6_refined_2,
+ FE_DGP_2d::dgp6_into_dgp6_refined_3 }
};
template <>
FE_DGP<3>::Matrices::embedding[][GeometryInfo<3>::children_per_cell] =
{
{ FE_DGP_3d::dgp0_into_dgp0_refined_0,
- FE_DGP_3d::dgp0_into_dgp0_refined_1,
- FE_DGP_3d::dgp0_into_dgp0_refined_2,
- FE_DGP_3d::dgp0_into_dgp0_refined_3,
- FE_DGP_3d::dgp0_into_dgp0_refined_4,
- FE_DGP_3d::dgp0_into_dgp0_refined_5,
- FE_DGP_3d::dgp0_into_dgp0_refined_6,
- FE_DGP_3d::dgp0_into_dgp0_refined_7},
- { FE_DGP_3d::dgp1_into_dgp1_refined_0,
- FE_DGP_3d::dgp1_into_dgp1_refined_1,
- FE_DGP_3d::dgp1_into_dgp1_refined_2,
- FE_DGP_3d::dgp1_into_dgp1_refined_3,
- FE_DGP_3d::dgp1_into_dgp1_refined_4,
- FE_DGP_3d::dgp1_into_dgp1_refined_5,
- FE_DGP_3d::dgp1_into_dgp1_refined_6,
- FE_DGP_3d::dgp1_into_dgp1_refined_7},
- { FE_DGP_3d::dgp2_into_dgp2_refined_0,
- FE_DGP_3d::dgp2_into_dgp2_refined_1,
- FE_DGP_3d::dgp2_into_dgp2_refined_2,
- FE_DGP_3d::dgp2_into_dgp2_refined_3,
- FE_DGP_3d::dgp2_into_dgp2_refined_4,
- FE_DGP_3d::dgp2_into_dgp2_refined_5,
- FE_DGP_3d::dgp2_into_dgp2_refined_6,
- FE_DGP_3d::dgp2_into_dgp2_refined_7},
- { FE_DGP_3d::dgp3_into_dgp3_refined_0,
- FE_DGP_3d::dgp3_into_dgp3_refined_1,
- FE_DGP_3d::dgp3_into_dgp3_refined_2,
- FE_DGP_3d::dgp3_into_dgp3_refined_3,
- FE_DGP_3d::dgp3_into_dgp3_refined_4,
- FE_DGP_3d::dgp3_into_dgp3_refined_5,
- FE_DGP_3d::dgp3_into_dgp3_refined_6,
- FE_DGP_3d::dgp3_into_dgp3_refined_7},
- { FE_DGP_3d::dgp4_into_dgp4_refined_0,
- FE_DGP_3d::dgp4_into_dgp4_refined_1,
- FE_DGP_3d::dgp4_into_dgp4_refined_2,
- FE_DGP_3d::dgp4_into_dgp4_refined_3,
- FE_DGP_3d::dgp4_into_dgp4_refined_4,
- FE_DGP_3d::dgp4_into_dgp4_refined_5,
- FE_DGP_3d::dgp4_into_dgp4_refined_6,
- FE_DGP_3d::dgp4_into_dgp4_refined_7}
+ FE_DGP_3d::dgp0_into_dgp0_refined_1,
+ FE_DGP_3d::dgp0_into_dgp0_refined_2,
+ FE_DGP_3d::dgp0_into_dgp0_refined_3,
+ FE_DGP_3d::dgp0_into_dgp0_refined_4,
+ FE_DGP_3d::dgp0_into_dgp0_refined_5,
+ FE_DGP_3d::dgp0_into_dgp0_refined_6,
+ FE_DGP_3d::dgp0_into_dgp0_refined_7},
+ { FE_DGP_3d::dgp1_into_dgp1_refined_0,
+ FE_DGP_3d::dgp1_into_dgp1_refined_1,
+ FE_DGP_3d::dgp1_into_dgp1_refined_2,
+ FE_DGP_3d::dgp1_into_dgp1_refined_3,
+ FE_DGP_3d::dgp1_into_dgp1_refined_4,
+ FE_DGP_3d::dgp1_into_dgp1_refined_5,
+ FE_DGP_3d::dgp1_into_dgp1_refined_6,
+ FE_DGP_3d::dgp1_into_dgp1_refined_7},
+ { FE_DGP_3d::dgp2_into_dgp2_refined_0,
+ FE_DGP_3d::dgp2_into_dgp2_refined_1,
+ FE_DGP_3d::dgp2_into_dgp2_refined_2,
+ FE_DGP_3d::dgp2_into_dgp2_refined_3,
+ FE_DGP_3d::dgp2_into_dgp2_refined_4,
+ FE_DGP_3d::dgp2_into_dgp2_refined_5,
+ FE_DGP_3d::dgp2_into_dgp2_refined_6,
+ FE_DGP_3d::dgp2_into_dgp2_refined_7},
+ { FE_DGP_3d::dgp3_into_dgp3_refined_0,
+ FE_DGP_3d::dgp3_into_dgp3_refined_1,
+ FE_DGP_3d::dgp3_into_dgp3_refined_2,
+ FE_DGP_3d::dgp3_into_dgp3_refined_3,
+ FE_DGP_3d::dgp3_into_dgp3_refined_4,
+ FE_DGP_3d::dgp3_into_dgp3_refined_5,
+ FE_DGP_3d::dgp3_into_dgp3_refined_6,
+ FE_DGP_3d::dgp3_into_dgp3_refined_7},
+ { FE_DGP_3d::dgp4_into_dgp4_refined_0,
+ FE_DGP_3d::dgp4_into_dgp4_refined_1,
+ FE_DGP_3d::dgp4_into_dgp4_refined_2,
+ FE_DGP_3d::dgp4_into_dgp4_refined_3,
+ FE_DGP_3d::dgp4_into_dgp4_refined_4,
+ FE_DGP_3d::dgp4_into_dgp4_refined_5,
+ FE_DGP_3d::dgp4_into_dgp4_refined_6,
+ FE_DGP_3d::dgp4_into_dgp4_refined_7}
};
// Initialize FEValues for fe1 at
// the unit support points of the
// fe2 element.
- const typename std::vector<Point<dim> > &
+ const std::vector<Point<dim> > &
fe2_support_points = fe2.get_unit_support_points ();
Assert(fe2_support_points.size()==fe2.dofs_per_cell,
template <int dim>
template <class InputVector, typename number>
void FEValuesBase<dim>::get_function_values (const InputVector &fe_function,
- typename std::vector<number> &values) const
+ std::vector<number> &values) const
{
Assert (this->update_flags & update_values, ExcAccessToUninitializedField());
Assert (fe->n_components() == 1,
template <int dim>
template <class InputVector, typename number>
void FEValuesBase<dim>::get_function_values (const InputVector &fe_function,
- typename std::vector<Vector<number> > &values) const
+ std::vector<Vector<number> > &values) const
{
Assert (n_quadrature_points == values.size(),
ExcWrongVectorSize(values.size(), n_quadrature_points));
template <int dim>
-const typename std::vector<Point<dim> > &
+const std::vector<Point<dim> > &
FEValuesBase<dim>::get_quadrature_points () const
{
Assert (this->update_flags & update_q_points, ExcAccessToUninitializedField());
void
FEValuesBase<dim>::
get_function_grads (const InputVector &fe_function,
- typename std::vector<Tensor<1,dim> > &gradients) const
+ std::vector<Tensor<1,dim> > &gradients) const
{
Assert (this->update_flags & update_gradients, ExcAccessToUninitializedField());
void
FEValuesBase<dim>::
get_function_grads (const InputVector &fe_function,
- typename std::vector<typename std::vector<Tensor<1,dim> > > &gradients) const
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (n_quadrature_points == gradients.size(),
ExcWrongNoOfComponents());
void
FEValuesBase<dim>::
get_function_2nd_derivatives (const InputVector &fe_function,
- typename std::vector<Tensor<2,dim> > &second_derivatives) const
+ std::vector<Tensor<2,dim> > &second_derivatives) const
{
Assert (fe->n_components() == 1,
ExcWrongNoOfComponents());
void
FEValuesBase<dim>::
get_function_2nd_derivatives (const InputVector &fe_function,
- typename std::vector<typename std::vector<Tensor<2,dim> > > &second_derivs) const
+ std::vector<std::vector<Tensor<2,dim> > > &second_derivs) const
{
Assert (n_quadrature_points == second_derivs.size(),
ExcWrongNoOfComponents());
template <int dim>
-const typename std::vector<Point<dim> > &
+const std::vector<Point<dim> > &
FEFaceValuesBase<dim>::get_normal_vectors () const
{
Assert (this->update_flags & update_normal_vectors,
template <int dim>
-const typename std::vector<Tensor<1,dim> > &
+const std::vector<Tensor<1,dim> > &
FEFaceValuesBase<dim>::get_boundary_forms () const
{
Assert (this->update_flags & update_boundary_forms,
template <int dim>
void
MappingC1<dim>::add_line_support_points (const typename Triangulation<dim>::cell_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert (false, ExcNotImplemented());
};
template <int dim>
void
MappingC1<dim>::add_quad_support_points (const typename Triangulation<dim>::cell_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert (false, ExcNotImplemented());
};
const unsigned int face_no,
const unsigned int sub_no,
InternalData &data,
- typename std::vector<Point<dim> > &quadrature_points,
- typename std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &normal_vectors) const
{
UpdateFlags update_flags(data.current_update_flags());
MappingCartesian<dim>::fill_fe_values (const typename DoFHandler<dim>::cell_iterator& cell,
const Quadrature<dim>& q,
typename Mapping<dim>::InternalDataBase& mapping_data,
- typename std::vector<Point<dim> >& quadrature_points,
+ std::vector<Point<dim> >& quadrature_points,
std::vector<double>& JxW_values) const
{
// convert data object to internal
// possible
InternalData &data = dynamic_cast<InternalData&> (mapping_data);
- typename std::vector<Point<dim> > dummy;
+ std::vector<Point<dim> > dummy;
compute_fill (cell, invalid_face_number, invalid_face_number,
data,
const unsigned int face_no,
const Quadrature<dim-1> &q,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_forms,
- typename std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Tensor<1,dim> > &boundary_forms,
+ std::vector<Point<dim> > &normal_vectors) const
{
// convert data object to internal
// data for this class. fails with
const unsigned int sub_no,
const Quadrature<dim-1> &q,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &boundary_forms,
- typename std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Tensor<1,dim> > &boundary_forms,
+ std::vector<Point<dim> > &normal_vectors) const
{
// convert data object to internal
// data for this class. fails with
template<int dim>
void
-MappingQ<dim>::compute_shapes_virtual (const typename std::vector<Point<dim> > &unit_points,
+MappingQ<dim>::compute_shapes_virtual (const std::vector<Point<dim> > &unit_points,
typename MappingQ1<dim>::InternalData &data) const
{
const unsigned int n_points=unit_points.size();
MappingQ<dim>::fill_fe_values (const typename DoFHandler<dim>::cell_iterator &cell,
const Quadrature<dim> &q,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values) const
{
// convert data object to internal
const unsigned int face_no,
const Quadrature<dim-1> &q,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &exterior_forms,
- typename std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Tensor<1,dim> > &exterior_forms,
+ std::vector<Point<dim> > &normal_vectors) const
{
// convert data object to internal
// data for this class. fails with
const unsigned int sub_no,
const Quadrature<dim-1> &q,
typename Mapping<dim>::InternalDataBase &mapping_data,
- typename std::vector<Point<dim> > &quadrature_points,
+ std::vector<Point<dim> > &quadrature_points,
std::vector<double> &JxW_values,
- typename std::vector<Tensor<1,dim> > &exterior_forms,
- typename std::vector<Point<dim> > &normal_vectors) const
+ std::vector<Tensor<1,dim> > &exterior_forms,
+ std::vector<Point<dim> > &normal_vectors) const
{
// convert data object to internal
// data for this class. fails with
template <int dim>
void
MappingQ<dim>::apply_laplace_vector(const std::vector<std::vector<double> > &lvs,
- typename std::vector<Point<dim> > &a) const
+ std::vector<Point<dim> > &a) const
{
Assert(lvs.size()!=0, ExcLaplaceVectorNotSet(degree));
const unsigned int n_inner_apply=lvs.size();
void
MappingQ<dim>::compute_mapping_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const
+ std::vector<Point<dim> > &a) const
{
// if this is a cell for which we
// want to compute the full
template <int dim>
void
MappingQ<dim>::compute_support_points_laplace(const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const
+ std::vector<Point<dim> > &a) const
{
// in any case, we need the
// vertices first
template <int dim>
void
MappingQ<dim>::compute_support_points_simple(const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const
+ std::vector<Point<dim> > &a) const
{
Assert(a.size()==0, ExcInternalError());
// the vertices first
template <int dim>
void
MappingQ<dim>::add_line_support_points (const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const
+ std::vector<Point<dim> > &a) const
{
static const StraightBoundary<dim> straight_boundary;
// if we only need the midpoint,
template<int dim>
void
MappingQ<dim>::add_quad_support_points(const typename Triangulation<dim>::cell_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert (dim > 2, ExcImpossibleInDim(dim));
}
template <int dim>
void
MappingQ<dim>::fill_quad_support_points_simple (const typename Triangulation<dim>::cell_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{}
void
MappingQ1Eulerian<dim>::compute_mapping_support_points(
const typename Triangulation<dim>::cell_iterator &cell,
- typename std::vector<Point<dim> > &a) const
+ std::vector<Point<dim> > &a) const
{
// The assertions can not be in the
template <int dim>
void GridGenerator::laplace_transformation (Triangulation<dim> &tria,
- const typename std::map<unsigned int,Point<dim> > &new_points)
+ const std::map<unsigned int,Point<dim> > &new_points)
{
// first provide everything that is
// needed for solving a Laplace
template <int dim>
void
-GridIn<dim>::delete_unused_vertices (typename std::vector<Point<dim> > &vertices,
- typename std::vector<CellData<dim> > &cells,
+GridIn<dim>::delete_unused_vertices (std::vector<Point<dim> > &vertices,
+ std::vector<CellData<dim> > &cells,
SubCellData &subcelldata)
{
// first check which vertices are
template <int dim>
-void GridIn<dim>::debug_output_grid (const typename std::vector<CellData<dim> > &/*cells*/,
- const typename std::vector<Point<dim> > &/*vertices*/,
- std::ostream &/*out*/)
+void GridIn<dim>::debug_output_grid (const std::vector<CellData<dim> > &/*cells*/,
+ const std::vector<Point<dim> > &/*vertices*/,
+ std::ostream &/*out*/)
{
Assert (false, ExcNotImplemented());
};
Quadrature<dim> *q_projector=0;
if (mapping!=0)
{
- typename std::vector<Point<dim-1> > boundary_points(n_points);
+ std::vector<Point<dim-1> > boundary_points(n_points);
for (unsigned int i=0; i<n_points; ++i)
boundary_points[i](0)= 1.*(i+1)/(n_points+1);
// points on a face and
// project them onto the
// faces of a unit cell
- typename std::vector<Point<dim-1> > boundary_points (n_points);
+ std::vector<Point<dim-1> > boundary_points (n_points);
for (unsigned int i=0; i<n_points; ++i)
boundary_points[i](0) = 1.*(i+1)/(n_points+1);
template <int dim>
void
-GridReordering<dim>::Cell::insert_faces (typename std::map<Face,FaceData> &/*global_faces*/)
+GridReordering<dim>::Cell::insert_faces (std::map<Face,FaceData> &/*global_faces*/)
{
Assert (false, ExcNotImplemented());
};
template <int dim>
inline
-void GridReordering<dim>::track_back (typename std::vector<Cell> &cells,
- RotationStack &rotation_states,
- const unsigned tbtc)
+void GridReordering<dim>::track_back (std::vector<Cell> &cells,
+ RotationStack &rotation_states,
+ const unsigned tbtc)
{
unsigned int track_back_to_cell = tbtc;
template <int dim>
-bool GridReordering<dim>::try_rotate_single_neighbors (typename std::vector<Cell> &cells,
- RotationStack &rotation_states)
+bool GridReordering<dim>::try_rotate_single_neighbors (std::vector<Cell> &cells,
+ RotationStack &rotation_states)
{
// the rotation state of the cell
// which we try to add by rotating
template <int dim>
-void GridReordering<dim>::find_reordering (typename std::vector<Cell> &cells,
- typename std::vector<CellData<dim> > &original_cells,
+void GridReordering<dim>::find_reordering (std::vector<Cell> &cells,
+ std::vector<CellData<dim> > &original_cells,
const std::vector<unsigned int> &new_cell_numbers)
{
// cout << "Starting..." << flush;
template <int dim>
std::vector<unsigned int>
-GridReordering<dim>::presort_cells (typename std::vector<Cell> &cells,
- typename std::map<Face,FaceData> &faces)
+GridReordering<dim>::presort_cells (std::vector<Cell> &cells,
+ std::map<Face,FaceData> &faces)
{
// first find the cell with the
// least neighbors
template <int dim>
-void GridReordering<dim>::reorder_cells (typename std::vector<CellData<dim> > &original_cells)
+void GridReordering<dim>::reorder_cells (std::vector<CellData<dim> > &original_cells)
{
// we need more information than
// provided by the input parameter,
template <int dim>
void
-PersistentTriangulation<dim>::create_triangulation (const typename std::vector<Point<dim> > &,
- const typename std::vector<CellData<dim> > &,
+PersistentTriangulation<dim>::create_triangulation (const std::vector<Point<dim> > &,
+ const std::vector<CellData<dim> > &,
const SubCellData &)
{
Assert (false, ExcFunctionNotUseful());
template <int dim>
-const typename std::vector<Point<dim> > &
+const std::vector<Point<dim> > &
Triangulation<dim>::get_vertices () const
{
return vertices;
void
Boundary<dim>::
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert (false, ExcPureVirtualFunctionCalled());
};
void
Boundary<dim>::
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert (false, ExcPureVirtualFunctionCalled());
};
void
StraightBoundary<dim>::
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert(false, typename Boundary<dim>::ExcFunctionNotUseful(dim));
}
void
StraightBoundary<dim>::
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
const unsigned int n=points.size();
Assert(n>0, ExcInternalError());
void
StraightBoundary<dim>::
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert(false, typename Boundary<dim>::ExcFunctionNotUseful(dim));
}
void
StraightBoundary<dim>::
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
const unsigned int n=points.size(),
m=static_cast<unsigned int>(std::sqrt(static_cast<double>(n)));
void
CylinderBoundary<dim>::get_intermediate_points_on_line (
const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
if (points.size()==1)
points[0]=get_new_point_on_line(line);
void
CylinderBoundary<dim>::get_intermediate_points_between_points (
const Point<dim> &v0, const Point<dim> &v1,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
const unsigned int n=points.size();
Assert(n>0, ExcInternalError());
void
CylinderBoundary<dim>::get_intermediate_points_on_quad (
const typename Triangulation<dim>::quad_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert(false, Boundary<dim>::ExcFunctionNotUseful(dim));
}
void
HyperBallBoundary<dim>::get_intermediate_points_on_line (
const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
if (points.size()==1)
points[0]=get_new_point_on_line(line);
void
HyperBallBoundary<dim>::get_intermediate_points_between_points (
const Point<dim> &p0, const Point<dim> &p1,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
const unsigned int n=points.size();
Assert(n>0, ExcInternalError());
void
HyperBallBoundary<dim>::get_intermediate_points_on_quad (
const typename Triangulation<dim>::quad_iterator &,
- typename std::vector<Point<dim> > &) const
+ std::vector<Point<dim> > &) const
{
Assert(false, Boundary<dim>::ExcFunctionNotUseful(dim));
}
void
HalfHyperBallBoundary<dim>::
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
// check whether center of object is
// at x==0, since then it belongs
void
HalfHyperBallBoundary<dim>::
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
// check whether center of object is
// at x==0, since then it belongs
void
HalfHyperShellBoundary<dim>::
get_intermediate_points_on_line (const typename Triangulation<dim>::line_iterator &line,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
// check whether center of object is
// at x==0, since then it belongs
void
HalfHyperShellBoundary<dim>::
get_intermediate_points_on_quad (const typename Triangulation<dim>::quad_iterator &quad,
- typename std::vector<Point<dim> > &points) const
+ std::vector<Point<dim> > &points) const
{
// check whether center of object is
// at x==0, since then it belongs
// also delete vector of vertex
// indices
- typename std::vector<MGVertexDoFs> tmp;
+ std::vector<MGVertexDoFs> tmp;
std::swap (mg_vertex_dofs, tmp);
};
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
-const typename std::vector< ::DataOutBase::Patch<patch_dim, patch_space_dim> > &
+const std::vector< ::DataOutBase::Patch<patch_dim, patch_space_dim> > &
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::get_patches () const
{
return patches;
// clear the patches array
if (true)
{
- typename std::vector< ::DataOutBase::Patch<dim> > dummy;
+ std::vector< ::DataOutBase::Patch<dim> > dummy;
this->patches.swap (dummy);
};
template <int dim>
-const typename std::vector< ::DataOutBase::Patch<dim+1> > &
+const std::vector< ::DataOutBase::Patch<dim+1> > &
DataOutStack<dim>::get_patches () const
{
return patches;
template <typename number>
-void Histogram::evaluate (const typename std::vector<Vector<number> > &values,
- const std::vector<double> &_y_values,
- const unsigned int n_intervals,
- const IntervalSpacing interval_spacing)
+void Histogram::evaluate (const std::vector<Vector<number> > &values,
+ const std::vector<double> &y_values_,
+ const unsigned int n_intervals,
+ const IntervalSpacing interval_spacing)
{
Assert (values.size() > 0, ExcEmptyData());
Assert (n_intervals > 0, ExcInvalidIntervals());
for (unsigned int i=0; i<values.size(); ++i)
Assert (values[i].size() > 0, ExcEmptyData());
- Assert (values.size() == _y_values.size(),
- ExcIncompatibleArraySize(values.size(), _y_values.size()));
+ Assert (values.size() == y_values_.size(),
+ ExcIncompatibleArraySize(values.size(), y_values_.size()));
// store y_values
- y_values = _y_values;
+ y_values = y_values_;
// first find minimum and maximum value
// in the indicators
template<int dim, typename number>
void
SolutionTransfer<dim, number>::
-prepare_for_coarsening_and_refinement(const typename std::vector<Vector<number> > &all_in)
+prepare_for_coarsening_and_refinement(const std::vector<Vector<number> > &all_in)
{
Assert(prepared_for!=pure_refinement, ExcAlreadyPrepForRef());
Assert(!prepared_for!=coarsening_and_refinement,
template<int dim, typename number>
void SolutionTransfer<dim, number>::
-interpolate (const typename std::vector<Vector<number> > &all_in,
- typename std::vector<Vector<number> > &all_out) const
+interpolate (const std::vector<Vector<number> > &all_in,
+ std::vector<Vector<number> > &all_out) const
{
Assert(prepared_for==coarsening_and_refinement, ExcNotPrepared());
for (unsigned int i=0; i<all_in.size(); ++i)
// avoided to evaluate
// the vectorfunction multiply at
// the same point on a cell.
- const typename std::vector<Point<dim> > &
+ const std::vector<Point<dim> > &
unit_support_points = fe.get_unit_support_points();
Assert (unit_support_points.size() != 0,
ExcNonInterpolatingFE());
// support points. this wil be used
// to obtain the quadrature points
// on the real cell's face
- const typename std::vector<Point<dim-1> >
+ const std::vector<Point<dim-1> >
& unit_support_points = fe.get_unit_face_support_points();
// check whether there are support
/**
* Array of sub-matrices.
*/
- typename std::vector<typename std::vector<SmartPointer<SparseMatrix<number> > > > sub_objects;
+ std::vector<std::vector<SmartPointer<SparseMatrix<number> > > > sub_objects;
};
/**
* Array of sparsity patterns.
*/
- typename std::vector<typename std::vector<SmartPointer<SparsityPatternBase> > > sub_objects;
+ std::vector<std::vector<SmartPointer<SparsityPatternBase> > > sub_objects;
/**
* Object storing and managing
/**
* Pointer to the array of components.
*/
- typename std::vector<Vector<Number> > components;
+ std::vector<Vector<Number> > components;
/**
* Object managing the
* freedom index and the value it
* shall have.
*/
- typedef typename std::pair<unsigned int,value_type> IndexValuePair;
+ typedef std::pair<unsigned int,value_type> IndexValuePair;
/**
* Default constructor. You will
* the value to which it shall be
* fixed.
*/
- typename std::vector<IndexValuePair> constraints;
+ std::vector<IndexValuePair> constraints;
/**
* Vector to be used as temporary
* matrix types.
*/
void get_column_entries (const unsigned int index,
- typename std::vector<IndexValuePair> &column_entries,
+ std::vector<IndexValuePair> &column_entries,
const bool matrix_is_symmetric) const;
};
template <typename number>
template <typename number2>
void
-FullMatrix<number>::add (const number s,const FullMatrix<number2>& src)
+FullMatrix<number>::add (const number s,
+ const FullMatrix<number2> &src)
{
Assert (this->data() != 0, ExcEmptyMatrix());
* memory in comparison with
* @p{inverse_type=double}.
*/
- typename std::vector<FullMatrix<inverse_type> > var_inverse;
+ std::vector<FullMatrix<inverse_type> > var_inverse;
/**
* Storage of the original diagonal blocks.
*
* Used by the blocked SSOR method.
*/
- typename std::vector<FullMatrix<inverse_type> > var_diagonal;
+ std::vector<FullMatrix<inverse_type> > var_diagonal;
/**
* Flag for diagonal compression.
* entries of a row ordered
* by column number.
*/
- typename std::vector<Entry> values;
+ std::vector<Entry> values;
};
*/
template <typename value>
unsigned int
- get_column_index_from_iterator (const typename std::pair<unsigned int, value> &i);
+ get_column_index_from_iterator (const std::pair<unsigned int, value> &i);
/**
* Likewise, but sometimes needed
*/
template <typename value>
unsigned int
- get_column_index_from_iterator (const typename std::pair<const unsigned int, value> &i);
+ get_column_index_from_iterator (const std::pair<const unsigned int, value> &i);
/**
* Make all sparse matrices
template <typename value>
inline
unsigned int
-SparsityPattern::get_column_index_from_iterator (const typename std::pair<unsigned int, value> &i)
+SparsityPattern::
+get_column_index_from_iterator (const std::pair<unsigned int, value> &i)
{
return i.first;
};
template <typename value>
inline
unsigned int
-SparsityPattern::get_column_index_from_iterator (const typename std::pair<const unsigned int, value> &i)
+SparsityPattern::get_column_index_from_iterator (const std::pair<const unsigned int, value> &i)
{
return i.first;
};
* vector is used, second the
* vector itself.
*/
- typedef typename std::pair<bool, Vector*> entry_type;
+ typedef std::pair<bool, Vector*> entry_type;
/**
* Array of allocated vectors.
*/
- typename std::vector<entry_type> pool;
+ std::vector<entry_type> pool;
/**
* Overall number of allocations.