* involving vectors and linear operators. This is done by storing the
* computational expression and only performing the computation when either
* the object is implicitly converted to a vector object, or
- * <code>apply</code> (or <code>apply_add</code>) is invoked by hand. This
- * avoids unnecessary temporary storage of intermediate results.
+ * PackagedOperation::apply() (or PackagedOperation::apply_add()) is
+ * invoked by hand. This avoids unnecessary temporary storage of
+ * intermediate results.
*
* As an example consider the addition of multiple vectors:
* @code
*
* dealii::Vector<double> residual = b - op_a * x;
* @endcode
+ * Here, the expression <code>b - op_a * x</code> results again in an
+ * object of type PackagedOperation that stores the <i>sequence of
+ * operations</i> that should be performed using the two vectors and the
+ * linear operator. Converting the expression to a vector (as happens here
+ * with the assignment to the vector <code>residual</code>) executes the
+ * computation (see the following note).
*
* @note
* Lazy evaluation of a computational expression necessarily involves
namespace
{
// Poor man's trait class that determines whether type T is a vector:
- // FIXME: Implement this as a proprer type trait - similar to
+ // FIXME: Implement this as a proper type trait - similar to
// isBlockVector
template <typename T>