* Compute the value of the <tt>i</tt>th polynomial at unit point
* <tt>p</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
double
compute_value(const unsigned int i, const Point<dim> &p) const;
* Compute the <tt>order</tt>th derivative of the <tt>i</tt>th polynomial
* at unit point <tt>p</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*
* @tparam order The order of the derivative.
*/
* Compute the gradient of the <tt>i</tt>th polynomial at unit point
* <tt>p</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
Tensor<1, dim>
compute_grad(const unsigned int i, const Point<dim> &p) const;
* Compute the second derivative (grad_grad) of the <tt>i</tt>th polynomial
* at unit point <tt>p</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
Tensor<2, dim>
compute_grad_grad(const unsigned int i, const Point<dim> &p) const;
*/
void
- compute(const Point<2> & unit_point,
- std::vector<double> & values,
- std::vector<Tensor<1, 2>> &grads,
- std::vector<Tensor<2, 2>> &grad_grads) const;
+ evaluate(const Point<2> & unit_point,
+ std::vector<double> & values,
+ std::vector<Tensor<1, 2>> &grads,
+ std::vector<Tensor<2, 2>> &grad_grads) const;
/**
* Compute the value of the <tt>i</tt>th polynomial at <tt>unit_point</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
double
* Compute the gradient of the <tt>i</tt>th polynomial at
* <tt>unit_point</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
Tensor<1, 2>
* Compute the second derivative (grad_grad) of the <tt>i</tt>th polynomial
* at <tt>unit_point</tt>.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
Tensor<2, 2>
/**
* <tt>order</tt>-th of basis function @p i at @p p.
*
- * Consider using compute() instead.
+ * Consider using evaluate() instead.
*/
template <int order>
Tensor<order, dim>
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each point value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function with
+ * several times. Instead use the evaluate() function with
* <tt>values.size()==</tt>n() to get the point values of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with the
+ * several times. Instead use the evaluate() function, see above, with the
* size of the appropriate parameter set to n() to get the point value of
* all tensor polynomials all at once and in a much more efficient way.
*
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with
+ * several times. Instead use the evaluate() function, see above, with
* <tt>grads.size()==</tt>n() to get the point value of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with
+ * several times. Instead use the evaluate() function, see above, with
* <tt>grad_grads.size()==</tt>n() to get the point value of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with the
+ * several times. Instead use the evaluate() function, see above, with the
* size of the appropriate parameter set to n() to get the point value of
* all tensor polynomials all at once and in a much more efficient way.
*
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each point value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function with
+ * several times. Instead use the evaluate() function with
* <tt>values.size()==</tt>n() to get the point values of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with the
+ * several times. Instead use the evaluate() function, see above, with the
* size of the appropriate parameter set to n() to get the point value of
* all tensor polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with
+ * several times. Instead use the evaluate() function, see above, with
* <tt>grads.size()==</tt>n() to get the point value of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with
+ * several times. Instead use the evaluate() function, see above, with
* <tt>grad_grads.size()==</tt>n() to get the point value of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each point value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function with
+ * several times. Instead use the evaluate() function with
* <tt>values.size()==</tt>n() to get the point values of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with the
+ * several times. Instead use the evaluate() function, see above, with the
* size of the appropriate parameter set to n() to get the point value of
* all tensor polynomials all at once and in a much more efficient way.
*
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with
+ * several times. Instead use the evaluate() function, see above, with
* <tt>grads.size()==</tt>n() to get the point value of all tensor
* polynomials all at once and in a much more efficient way.
*/
* Note, that using this function within a loop over all tensor product
* polynomials is not efficient, because then each derivative value of the
* underlying (one-dimensional) polynomials is (unnecessarily) computed
- * several times. Instead use the compute() function, see above, with
+ * several times. Instead use the evaluate() function, see above, with
* <tt>grad_grads.size()==</tt>n() to get the point value of all tensor
* polynomials all at once and in a much more efficient way.
*/
}
void
-PolynomialsAdini::compute(const Point<2> & unit_point,
- std::vector<double> & values,
- std::vector<Tensor<1, 2>> &grads,
- std::vector<Tensor<2, 2>> &grad_grads) const
+PolynomialsAdini::evaluate(const Point<2> & unit_point,
+ std::vector<double> & values,
+ std::vector<Tensor<1, 2>> &grads,
+ std::vector<Tensor<2, 2>> &grad_grads) const
{
if (values.empty() == false) // do not bother if empty
{