// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*
* Access to function objects therefore is through the following
* methods:
- * @begin{verbatim}
+ * @code
* // access to one component at one point
* double value (const Point<dim> &p,
* const unsigned int component = 0) const;
* // return all components at one point
* void vector_value (const Point<dim> &p,
* Vector<double> &value) const;
- * @end{verbatim}
+ * @endcode
*
* For more efficiency, there are other functions returning one or all
* components at a list of points at once:
- * @begin{verbatim}
+ * @code
* // access to one component at several points
* void value_list (const std::vector<Point<dim> > &point_list,
* std::vector<double> &value_list,
* // return all components at several points
* void vector_value_list (const std::vector<Point<dim> > &point_list,
* std::vector<Vector<double> > &value_list) const;
- * @end{verbatim}
+ * @endcode
*
* Furthermore, there are functions returning the gradient of the
* function at one or several points.
*
* You will usually only overload those functions you need; the
- * functions returning several values at a time (@p{value_list},
- * @p{vector_value_list}, and gradient analoga) will call those
- * returning only one value (@p{value}, @p{vector_value}, and gradient
+ * functions returning several values at a time (value_list(),
+ * vector_value_list(), and gradient analoga) will call those
+ * returning only one value (value(), vector_value(), and gradient
* analoga), while those ones will throw an exception when called but
* not overloaded.
*
* Note however, that the functions returning all components of the
- * function at one or several points (i.e. @p{vector_value},
- * @p{vector_value_list}), will not call the function returning one
+ * function at one or several points (i.e. vector_value(),
+ * vector_value_list()), will not call the function returning one
* component at one point repeatedly, once for each point and
* component. The reason is efficiency: this would amount to too many
* virtual function calls. If you have vector-valued functions, you
*
*
* Support for time dependant functions can be found in the base
- * class @p{FunctionTime}.
+ * class FunctionTime.
*
- * @em{Note}: if the functions you are dealing with have sizes which
- * are a priori known (for example, @p{dim} elements), you might
- * consider using the @p{TensorFunction} class instead.
+ * @note if the functions you are dealing with have sizes which
+ * are a priori known (for example, <tt>dim</tt> elements), you might
+ * consider using the TensorFunction class instead.
*
* @author Wolfgang Bangerth, 1998, 1999
*/
* given point.
*
* Be default, this function
- * repeatedly calls the other
- * @p{operator()} for each
- * component separately, to fill
- * the output array.
+ * repeatedly calls value() for
+ * each component separately, to
+ * fill the output array.
*
- * @p{values} shall have the right
+ * <tt>values</tt> shall have the right
* size beforehand,
- * i.e. @p{n_components}.
+ * i.e. #n_components.
*/
virtual void vector_value (const Point<dim> &p,
Vector<double> &values) const;
/**
- * Set @p{values} to the point
+ * Set <tt>values</tt> to the point
* values of the specified
* component of the function at
- * the @p{points}. It is assumed
- * that @p{values} already has the
+ * the <tt>points</tt>. It is assumed
+ * that <tt>values</tt> already has the
* right size, i.e. the same
- * size as the @p{points} array.
+ * size as the <tt>points</tt> array.
*/
virtual void value_list (const std::vector<Point<dim> > &points,
std::vector<double> &values,
const unsigned int component = 0) const;
/**
- * Set @p{values} to the point
+ * Set <tt>values</tt> to the point
* values of the function at the
- * @p{points}. It is assumed that
- * @p{values} already has the right
+ * <tt>points</tt>. It is assumed that
+ * <tt>values</tt> already has the right
* size, i.e. the same size as
- * the @p{points} array, and that
+ * the <tt>points</tt> array, and that
* all elements be vectors with
* the same number of components
* as this function has.
std::vector<Tensor<1,dim> > &gradients) const;
/**
- * Set @p{gradients} to the
+ * Set <tt>gradients</tt> to the
* gradients of the specified
* component of the function at
- * the @p{points}. It is assumed
- * that @p{gradients} already has the
+ * the <tt>points</tt>. It is assumed
+ * that <tt>gradients</tt> already has the
* right size, i.e. the same
- * size as the @p{points} array.
+ * size as the <tt>points</tt> array.
*/
virtual void gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
- * Set @p{gradients} to the gradients of
- * the function at the @p{points},
+ * Set <tt>gradients</tt> to the gradients of
+ * the function at the <tt>points</tt>,
* for all components.
- * It is assumed that @p{gradients}
+ * It is assumed that <tt>gradients</tt>
* already has the right size, i.e.
- * the same size as the @p{points} array.
+ * the same size as the <tt>points</tt> array.
*
* The outer loop over
- * @p{gradients} is over the points
+ * <tt>gradients</tt> is over the points
* in the list, the inner loop
* over the different components
* of the function.
/**
* Compute the Laplacian of a
- * given component at point @p{p}.
+ * given component at point <tt>p</tt>.
*/
virtual double laplacian (const Point<dim> &p,
const unsigned int component = 0) const;
/**
* Compute the Laplacian of all
- * components at point @p{p} and
- * store them in @p{values}.
+ * components at point <tt>p</tt> and
+ * store them in <tt>values</tt>.
*/
virtual void vector_laplacian (const Point<dim> &p,
Vector<double> &values) const;
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{std::map} type with a
+ * STL <tt>std::map</tt> type with a
* certain number of
* elements?), this is only
* an estimate. however often
Vector<double> &return_value) const;
/**
- * Set @p{values} to the point values
- * of the function at the @p{points},
+ * Set <tt>values</tt> to the point values
+ * of the function at the <tt>points</tt>,
* for the given component.
- * It is assumed that @p{values}
+ * It is assumed that <tt>values</tt>
* already has the right size, i.e.
- * the same size as the @p{points}
+ * the same size as the <tt>points</tt>
* array.
*/
virtual void value_list (const std::vector<Point<dim> > &points,
const unsigned int component = 0) const;
/**
- * Set @p{values} to the point values
- * of the function at the @p{points},
+ * Set <tt>values</tt> to the point values
+ * of the function at the <tt>points</tt>,
* for all components.
- * It is assumed that @p{values}
+ * It is assumed that <tt>values</tt>
* already has the right size, i.e.
- * the same size as the @p{points}
+ * the same size as the <tt>points</tt>
* array.
*/
virtual void vector_value_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients) const;
/**
- * Set @p{gradients} to the gradients of
- * the function at the @p{points},
+ * Set <tt>gradients</tt> to the gradients of
+ * the function at the <tt>points</tt>,
* for the given component.
- * It is assumed that @p{values}
+ * It is assumed that <tt>values</tt>
* already has the right size, i.e.
- * the same size as the @p{points} array.
+ * the same size as the <tt>points</tt> array.
*/
virtual void gradient_list (const std::vector<Point<dim> > &points,
std::vector<Tensor<1,dim> > &gradients,
const unsigned int component = 0) const;
/**
- * Set @p{gradients} to the gradients of
- * the function at the @p{points},
+ * Set <tt>gradients</tt> to the gradients of
+ * the function at the <tt>points</tt>,
* for all components.
- * It is assumed that @p{gradients}
+ * It is assumed that <tt>gradients</tt>
* already has the right size, i.e.
- * the same size as the @p{points} array.
+ * the same size as the <tt>points</tt> array.
*
* The outer loop over
- * @p{gradients} is over the points
+ * <tt>gradients</tt> is over the points
* in the list, the inner loop
* over the different components
* of the function.
*
* Obviously, the derivates of this
* function are zero, which is why we derive this class from
- * @p{ZeroFunction}: we then only have to overload the value functions,
+ * <tt>ZeroFunction</tt>: we then only have to overload the value functions,
* not all the derivatives. In some way, it would be more obvious to
* do the derivation in the opposite direction, i.e. let
- * @p{ZeroFunction} be a more specialized version of @p{ConstantFunction};
+ * <tt>ZeroFunction</tt> be a more specialized version of <tt>ConstantFunction</tt>;
* however, this would be less efficient, since we could not make
- * use of the fact that the function value of the @p{ZeroFunction} is
+ * use of the fact that the function value of the <tt>ZeroFunction</tt> is
* known at compile time and need not be looked up somewhere in
* memory.
*
Vector<double> &return_value) const;
/**
- * Set @p{values} to the point values
- * of the function at the @p{points},
+ * Set <tt>values</tt> to the point values
+ * of the function at the <tt>points</tt>,
* for the given component.
- * It is assumed that @p{values}
+ * It is assumed that <tt>values</tt>
* already has the right size, i.e.
- * the same size as the @p{points}
+ * the same size as the <tt>points</tt>
* array.
*/
virtual void value_list (const std::vector<Point<dim> > &points,
const unsigned int component = 0) const;
/**
- * Set @p{values} to the point values
- * of the function at the @p{points},
+ * Set <tt>values</tt> to the point values
+ * of the function at the <tt>points</tt>,
* for all components.
- * It is assumed that @p{values}
+ * It is assumed that <tt>values</tt>
* already has the right size, i.e.
- * the same size as the @p{points}
+ * the same size as the <tt>points</tt>
* array.
*/
virtual void vector_value_list (const std::vector<Point<dim> > &points,
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{std::map} type with a
+ * STL <tt>std::map</tt> type with a
* certain number of
* elements?), this is only
* an estimate. however often
* zero only in one component.
*
* It is especially useful as a weight function for
- * @p{VectorTools::integrate_difference}, where it allows to integrate
+ * <tt>VectorTools::integrate_difference</tt>, where it allows to integrate
* only one component.
*
* @author Guido Kanschat, 2000
Vector<double> &return_value) const;
/**
- * Set @p{values} to the point values
- * of the function at the @p{points},
+ * Set <tt>values</tt> to the point values
+ * of the function at the <tt>points</tt>,
* for all components.
- * It is assumed that @p{values}
+ * It is assumed that <tt>values</tt>
* already has the right size, i.e.
- * the same size as the @p{points}
+ * the same size as the <tt>points</tt>
* array.
*/
virtual void vector_value_list (const std::vector<Point<dim> > &points,
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{std::map} type with a
+ * STL <tt>std::map</tt> type with a
* certain number of
* elements?), this is only
* an estimate. however often
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Smart pointers avoid destruction of an object in use. They can be used just
- * like a pointer (i.e. using the @p{*} and @p{->} operators and through casting)
+ * like a pointer (i.e. using the <tt>*</tt> and <tt>-></tt> operators and through casting)
* but make sure that the object pointed to is not deleted in the course of
* use of the pointer by signalling the pointee its use.
*
- * Objects pointed to should inherit @p{Subscriptor} or must implement
+ * Objects pointed to should inherit <tt>Subscriptor</tt> or must implement
* the same functionality. Null pointers are an exception from this
* rule and are allowed, too.
*
- * @p{SmartPointer} does NOT implement any memory handling! Especially,
- * deleting a @p{SmartPointer} does not delete the object. Writing
- * @begin{verbatim}
+ * SmartPointer does NOT implement any memory handling! Especially,
+ * deleting a SmartPointer does not delete the object. Writing
+ * @code
* SmartPointer<T> t = new T;
- * @end{verbatim}
+ * @endcode
* is a sure way to program a memory leak! The secure version is
- * @begin{verbatim}
+ * @code
* T* p = new T;
* {
* SmartPointer<T> t = p;
* ...
* }
* delete p;
- * @end{verbatim}
+ * @endcode
*
- * Note that a smart pointer can handle @p{const}ness of an object, i.e.
- * a @p{SmartPointer<const ABC>} really behaves as if it were a pointer to
+ * Note that a smart pointer can handle <tt>const</tt>ness of an object, i.e.
+ * a <tt>SmartPointer<const ABC></tt> really behaves as if it were a pointer to
* a constant object (disallowing write access when dereferenced), while
- * @p{SmartPointer<ABC>} is a mutable pointer.
+ * <tt>SmartPointer<ABC></tt> is a mutable pointer.
*
* @author Guido Kanschat, Wolfgang Bangerth, 1998, 1999, 2000
*/
/*
* Copy constructor for
- * @p{SmartPointer}. We do now
+ * SmartPointer. We do now
* copy the object subscribed to
- * from @p{tt}, but subscribe
+ * from <tt>tt</tt>, but subscribe
* ourselves to it again.
*/
SmartPointer (const SmartPointer<T> &tt);
SmartPointer<T> & operator= (T *tt);
/**
- *Assignment operator for
- * @p{SmartPointer}. The pointer
+ * Assignment operator for
+ * SmartPointer. The pointer
* subscribes to the new object
* automatically and unsubscribes
* to an old one if it exists.
* used by this class. Note in
* particular, that this only
* includes the amount of memory
- * used by @em{this} object, not
+ * used by <b>this</b> object, not
* by the object pointed to.
*/
unsigned int memory_consumption () const;