* the @p{coefficient} array
* minus one.
*/
- Polynomial (const vector<double> &coefficients);
+ Polynomial (const std::vector<double> &coefficients);
/**
* Default-Constructor.
* scheme for numerical stability
* of the evaluation.
*/
- void value (const double x,
- vector<double> &values) const;
+ void value (const double x,
+ std::vector<double> &values) const;
/**
* Exception
* passed down by derived
* classes.
*/
- vector<double> coefficients;
+ std::vector<double> coefficients;
};
* constructor.
*/
static
- vector<double>
+ std::vector<double>
compute_coefficients (const unsigned int n,
const unsigned int support_point);
};
* and will be copied into the
* member variable @p{polynomials}.
*/
- TensorProductPolynomials(const vector<SmartPointer<Polynomial> > &pols);
+ TensorProductPolynomials(const std::vector<SmartPointer<Polynomial> > &pols);
/**
* Calculates the polynomials
* case, the function will not
* compute these values.
*/
- void compute (const Point<dim> &unit_point,
- vector<double> &values,
- vector<Tensor<1,dim> > &grads,
- vector<Tensor<2,dim> > &grad_grads) const;
+ 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;
/**
* Returns the number of tensor
* Pointer to the @p{polynomials}
* given to the constructor.
*/
- vector<SmartPointer<Polynomial> > polynomials;
+ std::vector<SmartPointer<Polynomial> > polynomials;
/**
* Number of tensor product
#include <base/polynomial.h>
-Polynomial::Polynomial (const vector<double> &a):
+Polynomial::Polynomial (const std::vector<double> &a):
coefficients(a)
{}
-void Polynomial::value (const double x,
- vector<double> &values) const
+void Polynomial::value (const double x,
+ std::vector<double> &values) const
{
Assert (coefficients.size() > 0, ExcVoidPolynomial());
Assert (values.size() > 0, ExcEmptyArray());
// then do it properly by the
// full Horner scheme
const unsigned int m=coefficients.size();
- vector<double> a(coefficients);
+ std::vector<double> a(coefficients);
unsigned int j_faculty=1;
for (unsigned int j=0; j<values_size; ++j)
{
-vector<double>
+std::vector<double>
LagrangeEquidistant::compute_coefficients (const unsigned int n,
const unsigned int support_point)
{
- vector<double> a (n+1);
+ std::vector<double> a (n+1);
Assert(support_point<n+1, ExcIndexRange(support_point, 0, n+1));
switch (n)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
TensorProductPolynomials<dim>::TensorProductPolynomials(
- const vector<SmartPointer<Polynomial> > &pols):
+ const std::vector<SmartPointer<Polynomial> > &pols):
polynomials(pols),
n_tensor_pols(power(polynomials.size(), dim))
{}
template <int dim>
void TensorProductPolynomials<dim>::compute(
- const Point<dim> &p,
- vector<double> &values,
- vector<Tensor<1,dim> > &grads,
- vector<Tensor<2,dim> > &grad_grads) const
+ const Point<dim> &p,
+ std::vector<double> &values,
+ typename std::vector<Tensor<1,dim> > &grads,
+ typename std::vector<Tensor<2,dim> > &grad_grads) const
{
unsigned int n_pols=polynomials.size();
- vector<unsigned int> n_pols_to(dim+1);
+ std::vector<unsigned int> n_pols_to(dim+1);
n_pols_to[0]=1;
for (unsigned int i=0; i<dim; ++i)
n_pols_to[i+1]=n_pols_to[i]*n_pols;
v_size=3;
}
- vector<vector<vector<double> > > v(
- dim, vector<vector<double> > (n_pols, vector<double> (v_size)));
+ std::vector<std::vector<std::vector<double> > > v(
+ dim, std::vector<std::vector<double> > (n_pols, std::vector<double> (v_size)));
for (unsigned int d=0; d<dim; ++d)
{
- vector<vector<double> > &v_d=v[d];
+ std::vector<std::vector<double> > &v_d=v[d];
Assert(v_d.size()==n_pols, ExcInternalError());
for (unsigned int i=0; i<n_pols; ++i)
polynomials[i]->value(p(d), v_d[i]);