/**
* Derivative of a function object. The value access functions of
* this class return the directional derivative of a function with
- * respect to a direction provided on construction. If @p{b} is the
- * vector, the derivative @p{b . grad f} is computed. This derivative
- * is evaluated directly, not by computing the gradient of @p{f} and
- * its scalar product with @p{b}.
+ * respect to a direction provided on construction. If <tt>b</tt> is the
+ * vector, the derivative <tt>b . grad f</tt> is computed. This derivative
+ * is evaluated directly, not by computing the gradient of <tt>f</tt> and
+ * its scalar product with <tt>b</tt>.
*
* The derivative is computed numerically, using one of the provided
- * difference formulas (see @p{set_formula} for available
- * schemes). Experimenting with @p{h} and the difference scheme may be
+ * difference formulas (see <tt>set_formula</tt> for available
+ * schemes). Experimenting with <tt>h</tt> and the difference scheme may be
* necessary to obtain sufficient results.
*
* @author Guido Kanschat, 2000
* functions to compute
* derivatives of, the direction
* vector of the differentiation
- * and the step size @p{h} of the
+ * and the step size <tt>h</tt> of the
* difference formula.
*/
FunctionDerivative (const Function<dim> &f,
* This is the constructor for a
* variable velocity field. Most
* probably, a new object of
- * @p{FunctionDerivative} has to
+ * <tt>FunctionDerivative</tt> has to
* be constructed for each set of
* quadrature points.
*
*
* Formulas implemented right now
* are first order backward Euler
- * (@p{UpwindEuler}), second
+ * (<tt>UpwindEuler</tt>), second
* order symmetric Euler
- * (@p{Euler}) and a symmetric
+ * (<tt>Euler</tt>) and a symmetric
* fourth order formula
- * (@p{FourthOrder}).
+ * (<tt>FourthOrder</tt>).
*/
void set_formula (DifferenceFormula formula = Euler);
* 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
/**
- * The function @p{xy}. This function serves as an example for
+ * The function <tt>xy</tt>. This function serves as an example for
* a vanishing Laplacian.
*
* @author: Guido Kanschat, 2000
* A jump in x-direction transported into some direction.
*
* If the advection is parallel to the y-axis, the function is
- * @p{-atan(sx)}, where @p{s} is the steepness parameter provided in
+ * <tt>-atan(sx)</tt>, where <tt>s</tt> is the steepness parameter provided in
* the constructor.
*
* For different advection directions, this function will be turned in
* 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
double angle;
/**
- * Sine of @p{angle}.
+ * Sine of <tt>angle</tt>.
*/
double sine;
/**
- * Cosine of @p{angle}.
+ * Cosine of <tt>angle</tt>.
*/
double cosine;
};
/**
* 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 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 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 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;
* center of the ball and its
* radius.
*
- * If an argument @p{select} is
+ * If an argument <tt>select</tt> is
* given and not -1, the
* cut-off function will be
* non-zero for this component
/**
* Move the center of the ball
- * to new point @p{p}.
+ * to new point <tt>p</tt>.
*/
void new_center (const Point<dim>& p);
/**
- * Set the radius of the ball to @p{r}.
+ * Set the radius of the ball to <tt>r</tt>.
*/
void new_radius (const double r);
/**
* Component selected. If
- * @p{no_component}, the function is
+ * <tt>no_component</tt>, the function is
* the same in all components.
*/
const unsigned int selected;
/**
* Cut-off function in L-infinity for an arbitrary ball. This
- * function is the characteristic function of a ball around @p{center}
- * with a specified @p{radius}, that is,
+ * function is the characteristic function of a ball around <tt>center</tt>
+ * with a specified <tt>radius</tt>, that is,
* \f[
* f = \chi(B_r(c)).
* \f]
* center of the ball and its
* radius.
*
- * If an argument @p{select} is
+ * If an argument <tt>select</tt> is
* given and not -1, the
* cut-off function will be
* non-zero for this component
/**
* Cut-off function for an arbitrary ball. This function is a cone
- * with support in a ball of certain @p{radius} around @p{center}. The
+ * with support in a ball of certain <tt>radius</tt> around <tt>center</tt>. The
* maximum value is 1. If vector valued, it can be restricted
* to a single component.
*
* radius.
* radius.
*
- * If an argument @p{select} is
+ * If an argument <tt>select</tt> is
* given, the cut-off function
* will be non-zero for this
* component only.
/**
* Cut-off function for an arbitrary ball. This is the traditional
- * cut-off function in C-infinity for a ball of certain @p{radius}
- * around @p{center}, $f(r)=exp(1-1/(1-r**2/s**2))$, where $r$ is the
+ * cut-off function in C-infinity for a ball of certain <tt>radius</tt>
+ * around <tt>center</tt>, $f(r)=exp(1-1/(1-r**2/s**2))$, where $r$ is the
* distance to the center, and $s$ is the radius of the sphere. If
* vector valued, it can be restricted to a single component.
*
* radius.
* radius.
*
- * If an argument @p{select} is
+ * If an argument <tt>select</tt> is
* given, the cut-off function
* will be non-zero for this
* component only.
* normally does not create thousands of function objects, the gain in
* generality weighs out the fact that we need not store the time value
* for not time dependent problems. The second advantage is that the derived
- * standard classes like @p{ZeroFunction}, @p{ConstantFunction} etc also work
+ * standard classes like <tt>ZeroFunction</tt>, <tt>ConstantFunction</tt> etc also work
* for time dependent problems.
*
* Access to the time goes through the following functions:
* @begin{verbatim}
- * @item @p{get_time}: return the present value of the time variable.
- * @item @p{set_time}: set the time value to a specific value.
- * @item @p{advance_time}: increase the time by a certain time step.
+ * @item <tt>get_time</tt>: return the present value of the time variable.
+ * @item <tt>set_time</tt>: set the time value to a specific value.
+ * @item <tt>advance_time</tt>: increase the time by a certain time step.
* @end{verbatim}
* The latter two functions are virtual, so that derived classes can
* perform computations which need only be done once for every new time.
- * For example, if a time dependent function had a factor @p{sin(t)}, then
+ * For example, if a time dependent function had a factor <tt>sin(t)</tt>, then
* it may be a reasonable choice to calculate this factor in a derived
- * version of @p{set_time}, store it in a member variable and use that one
- * rather than computing it every time @p{operator()}, @p{value_list} or one
+ * version of <tt>set_time</tt>, store it in a member variable and use that one
+ * rather than computing it every time <tt>operator()</tt>, <tt>value_list</tt> or one
* of the other functions is called.
*
- * By default, the @p{advance_time} function calls the @p{set_time} function
+ * By default, the <tt>advance_time</tt> function calls the <tt>set_time</tt> function
* with the new time, so it is sufficient in most cases to overload only
- * @p{set_time} for computations as sketched out above.
+ * <tt>set_time</tt> for computations as sketched out above.
*
* The constructor of this class takes an initial value for the time
* variable, which defaults to zero. Because a default value is given,
* none of the derived classes needs to take an initial value for the
* time variable if not needed.
*
- * Once again the warning: do not use the @p{time} variable for any other
+ * Once again the warning: do not use the <tt>time</tt> variable for any other
* purpose than the intended one! This will inevitably lead to confusion.
*
*
double get_time () const;
/**
- * Set the time to @p{new_time}, overwriting
+ * Set the time to <tt>new_time</tt>, overwriting
* the old value.
*/
virtual void set_time (const double new_time);
/**
* Advance the time by the given
- * time step @p{delta_t}.
+ * time step <tt>delta_t</tt>.
*/
virtual void advance_time (const double delta_t);
#include <string>
/**
- * Identification of a program run. @p{JobIdentifier} determines the
+ * Identification of a program run. <tt>JobIdentifier</tt> determines the
* start time of a program run and stores it as a program
- * identifier. There exists a library object @p{dealjobid} of this
+ * identifier. There exists a library object <tt>dealjobid</tt> of this
* class. This object can be accessed by all output functions to
* provide an id for the current job.
*/
/**
* Constructor. Set program
* identifier to value of
- * @p{program_id} concatenated
+ * <tt>program_id</tt> concatenated
* with the present time.
*/
JobIdentifier();
static const char* program_id();
/**
- * Return the value of @p{id}.
+ * Return the value of <tt>id</tt>.
*/
const std::string operator () () const;
* @end{itemize}
*
* The usual usage of this class is through the pregenerated object
- * @p{deallog}. Typical steps are
+ * <tt>deallog</tt>. Typical steps are
* @begin{itemize}
- * @item @p{deallog.attach(std::ostream)}: write logging information into a file.
- * @item @p{deallog.depth_console(n)}: restrict output on screen to outer loops.
+ * @item <tt>deallog.attach(std::ostream)</tt>: write logging information into a file.
+ * @item <tt>deallog.depth_console(n)</tt>: restrict output on screen to outer loops.
* @item Before entering a new phase of your program, e.g. a new loop,
- * @p{deallog.push("loopname")}.
- * @item @p{deallog << anything << std::endl;} to write logging information
- * (Usage of @p{std::endl} is mandatory!).
- * @item @p{deallog.pop()} when leaving that stage entered with @p{push}.
+ * <tt>deallog.push("loopname")</tt>.
+ * @item <tt>deallog << anything << std::endl;</tt> to write logging information
+ * (Usage of <tt>std::endl</tt> is mandatory!).
+ * @item <tt>deallog.pop()</tt> when leaving that stage entered with <tt>push</tt>.
* @end{itemize}
*
* @author Guido Kanschat, Wolfgang Bangerth, 1999, 2003
/**
* Standard constructor, since we
* intend to provide an object
- * @p{deallog} in the library. Set the
- * standard output stream to @p{std::cerr}.
+ * <tt>deallog</tt> in the library. Set the
+ * standard output stream to <tt>std::cerr</tt>.
*/
LogStream ();
/**
* Enable output to a second
- * stream @p{o}.
+ * stream <tt>o</tt>.
*/
void attach (std::ostream& o);
/**
* Disable output to the second
* stream. You may want to call
- * @p{close} on the stream that was
+ * <tt>close</tt> on the stream that was
* previously attached to this object.
*/
void detach ();
/**
- * Gives the default stream (@p{std_out}).
+ * Gives the default stream (<tt>std_out</tt>).
*/
std::ostream& get_console ();
* function allows to restrict
* console output to the upmost
* levels of iterations. Only
- * output with less than @p{n}
+ * output with less than <tt>n</tt>
* prefixes is printed. By calling
- * this function with @p{n=0}, no
+ * this function with <tt>n=0</tt>, no
* console output will be written.
*
* The previous value of this
* Maximum number of levels to be
* written to the log file. The
* functionality is the same as
- * @p{depth_console}, nevertheless,
+ * <tt>depth_console</tt>, nevertheless,
* this function should be used
* with care, since it may spoile
* the value of a log file.
* Output time differences
* between consecutive logs. If
* this function is invoked with
- * @p{true}, the time difference
+ * <tt>true</tt>, the time difference
* between the previous log line
* and the recent one is
* printed. If it is invoked with
- * @p{false}, the accumulated
+ * <tt>false</tt>, the accumulated
* time since start of the
* program is printed (default
* behavior).
* manipulators. This passes on
* the whole thing to the
* template function with the
- * exception of the @p{std::endl}
+ * exception of the <tt>std::endl</tt>
* manipulator, for which special
* action is performed: set the
- * @p{was_endl} variable that
+ * <tt>was_endl</tt> variable that
* forces this object to generate
* a line head the next time
* something is written by this
* 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
/**
* Default stream, where the output
* is to go to. This stream defaults
- * to @p{std::cerr}, but can be set to another
+ * to <tt>std::cerr</tt>, but can be set to another
* stream through the constructor.
*/
std::ostream *std_out;
* will be a file stream.
*
* You can set and reset this stream
- * by the @p{attach} function.
+ * by the <tt>attach</tt> function.
*/
std::ostream *file;
* writing output. This function
* unifies the work that is
* common to the two
- * @p{operator<<} functions.
+ * <tt>operator<<</tt> functions.
*/
template <typename T>
void print (const T &t);
print (p);
// next check whether this is the
- // @p{endl} manipulator, and if so
+ // <tt>endl</tt> manipulator, and if so
// set a flag
std::ostream & (* const p_endl) (std::ostream&) = &std::endl;
if (p == p_endl)
LogStream::print (const T &t)
{
// if the previous command was an
- // @p{std::endl}, print the topmost
+ // <tt>std::endl</tt>, print the topmost
// prefix and a colon
if (was_endl)
{
// $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
* This namespace provides functions helping to determine the amount
* of memory used by objects. The goal is not necessarily to give the
* amount of memory used up to the last bit (what is the memory used
- * by an STL @p{std::map<>} object?), but rather to aid in the search for
+ * by an STL <tt>std::map<></tt> object?), but rather to aid in the search for
* memory bottlenecks.
*
* The functions in this namespace work basically by reducing each
* object to its basics as far as they are known from this place. They
* do not attempt to know what goes on in each object, if they are not
- * basic types (such as @p{int} or @p{double}) or STL containers (such
- * as @p{vectors}). The method goes as follows: if the object with
- * which a @p{memory_consumption} function from this namespace is an
- * atomic type, the return its size by applying the @p{sizeof}
+ * basic types (such as <tt>int</tt> or <tt>double</tt>) or STL containers (such
+ * as <tt>vectors</tt>). The method goes as follows: if the object with
+ * which a <tt>memory_consumption</tt> function from this namespace is an
+ * atomic type, the return its size by applying the <tt>sizeof</tt>
* operator to it. If this is not the case, then try to reduce it to
* more basic types.
*
- * For example, if it is a C-style array or a standard C++ @p{std::vector},
+ * For example, if it is a C-style array or a standard C++ <tt>std::vector</tt>,
* then sum up the sizes of the array elements by calling
- * @p{memory_consumption} on each of them. This way, we can also
- * reduce objects of type @p{std::vector<std::vector<double> >} to its atomic
+ * <tt>memory_consumption</tt> on each of them. This way, we can also
+ * reduce objects of type <tt>std::vector<std::vector<double> ></tt> to its atomic
* types, and can thus determine the memory used even if the sizes of
* the elements of the outermost vector differ (e.g. the first
* sub-vector has 3 and the second sub-vector has 10 elements).
*
* There are two exceptions to simply adding up the sizes of the
- * subobjects: for C++ @p{std::vector} objects, we also have to add the
- * size of the vector object, i.e. @p{sizeof(vector<T>)}, to the sizes
+ * subobjects: for C++ <tt>std::vector</tt> objects, we also have to add the
+ * size of the vector object, i.e. <tt>sizeof(vector<T>)</tt>, to the sizes
* of the elements. Secondly, for the most common used vectors, such
- * as @p{std::vector<double>} and @p{std::vector<unsigned int>} we determine the
+ * as <tt>std::vector<double></tt> and <tt>std::vector<unsigned int></tt> we determine the
* size without a loop but rather directly, since we know that the
* sizes of the elements are constant.
*
- * Finally, if we cannot reduce a type @p{T} further, because it is
+ * Finally, if we cannot reduce a type <tt>T</tt> further, because it is
* neither atomic nor a known C++ data type, we call a member function
- * @p{T::memory_consumption} on it, which we assume to exist. Almost
+ * <tt>T::memory_consumption</tt> on it, which we assume to exist. Almost
* all classes in the deal.II library have such a function. This way,
- * if we call @p{memory_consumption(v)} on a vector @p{v} of type
- * @p{FullMatrix<double>}, we first reduce this to a loop in which we
- * call @p{memory_consumption(v[i])}, and because there is no such
+ * if we call <tt>memory_consumption(v)</tt> on a vector <tt>v</tt> of type
+ * <tt>FullMatrix<double></tt>, we first reduce this to a loop in which we
+ * call <tt>memory_consumption(v[i])</tt>, and because there is no such
* function handling this explicitly, we try to call
- * @p{v[i].memory_consumption()}.
+ * <tt>v[i].memory_consumption()</tt>.
*
*
* @sect3{Extending this namespace}
*
* The functions in this namespace and the functionality provided by
* it live on the assumption that there is either a function
- * @p{memory_consumption(T)} in this namespace determining the amount
- * of memory use by objects of type @p{T}, or that the class @p{T} has
+ * <tt>memory_consumption(T)</tt> in this namespace determining the amount
+ * of memory use by objects of type <tt>T</tt>, or that the class <tt>T</tt> has
* a function of that name as member function. While the latter is
* true for almost all class in deal.II, we have only implemented the
* first kind of functions for the most common data types, such as
{
/**
* Determine the amount of memory
- * in bytes consumed by a @p{bool}
+ * in bytes consumed by a <tt>bool</tt>
* variable.
*/
inline
/**
* Determine the amount of memory
- * in bytes consumed by a @p{char}
+ * in bytes consumed by a <tt>char</tt>
* variable.
*/
inline
/**
* Determine the amount of memory
* in bytes consumed by a
- * @p{short int} variable.
+ * <tt>short int</tt> variable.
*/
inline
unsigned int memory_consumption (const short int);
/**
* Determine the amount of memory
* in bytes consumed by a
- * @p{short unsigned int} variable.
+ * <tt>short unsigned int</tt> variable.
*/
inline
unsigned int memory_consumption (const short unsigned int);
/**
* Determine the amount of memory
- * in bytes consumed by a @p{int}
+ * in bytes consumed by a <tt>int</tt>
* variable.
*/
inline
/**
* Determine the amount of memory
- * in bytes consumed by a @p{unsigned int}
+ * in bytes consumed by a <tt>unsigned int</tt>
* variable.
*/
inline
/**
* Determine the amount of memory
- * in bytes consumed by a @p{float}
+ * in bytes consumed by a <tt>float</tt>
* variable.
*/
inline
/**
* Determine the amount of memory
- * in bytes consumed by a @p{double}
+ * in bytes consumed by a <tt>double</tt>
* variable.
*/
inline
/**
* Determine an estimate of the
* amount of memory in bytes
- * consumed by a @p{std::string}
+ * consumed by a <tt>std::string</tt>
* variable.
*/
inline
/**
* Determine an estimate of the
* amount of memory in bytes
- * consumed by a @p{std::vector} of
+ * consumed by a <tt>std::vector</tt> of
* certain elements. It does so by
* looping over all elements of the
* vector and determining their
* sizes using the
- * @p{memory_consumption}
+ * <tt>memory_consumption</tt>
* functions. If the elements are
* of constant size, there might be
* another global function
- * @p{memory_consumption} for this
+ * <tt>memory_consumption</tt> for this
* data type or if there is a
* member function of that class of
* that names that returns a
* C-style array. Since in this
* library we do not usually
* store simple data elements
- * like @p{double}s in such
+ * like <tt>double</tt>s in such
* arrays (but rather use STL
- * @p{std::vector}s or deal.II
- * @p{Vector} objects), we do not
+ * <tt>std::vector</tt>s or deal.II
+ * <tt>Vector</tt> objects), we do not
* provide specializations like
- * for the @p{std::vector} arrays, but
+ * for the <tt>std::vector</tt> arrays, but
* always use the loop over all
* elements.
*/
* Specialization of the
* determination of the memory
* consumption of a vector, here
- * for a vector of @p{bool}s.
+ * for a vector of <tt>bool</tt>s.
*
* This is a special case, as the
* bools are not stored
* Specialization of the
* determination of the memory
* consumption of a vector, here
- * for a vector of @p{int}s.
+ * for a vector of <tt>int</tt>s.
*/
inline
unsigned int memory_consumption (const std::vector<int> &v);
* Specialization of the
* determination of the memory
* consumption of a vector, here
- * for a vector of @p{double}s.
+ * for a vector of <tt>double</tt>s.
*/
inline
unsigned int memory_consumption (const std::vector<double> &v);
* Specialization of the
* determination of the memory
* consumption of a vector, here
- * for a vector of @p{float}s.
+ * for a vector of <tt>float</tt>s.
*/
inline
unsigned int memory_consumption (const std::vector<float> &v);
* Specialization of the
* determination of the memory
* consumption of a vector, here
- * for a vector of @p{char}s.
+ * for a vector of <tt>char</tt>s.
*/
inline
unsigned int memory_consumption (const std::vector<char> &v);
* Specialization of the
* determination of the memory
* consumption of a vector, here
- * for a vector of @p{unsigned char}s.
+ * for a vector of <tt>unsigned char</tt>s.
*/
inline
unsigned int memory_consumption (const std::vector<unsigned char> &v);
* by the object pointed to.
*
* Note that we needed this
- * function since @p{void} is no
- * type and a @p{void*} is thus
+ * function since <tt>void</tt> is no
+ * type and a <tt>void*</tt> is thus
* not caught by the general
- * @p{T*} template function
+ * <tt>T*</tt> template function
* above.
*/
inline
* not explicitly listed: try if
* there is a member function
* called
- * @p{memory_consumption}. If
+ * <tt>memory_consumption</tt>. If
* this is not the case, then the
* compiler will in any case
* complain that this last exit
// now comes the implementation of these functions
+/// @if NoDoc
+
namespace MemoryConsumption
{
inline
}
}
-
+/// @endif
#endif
* use in multithreaded programs. At the moment this is just the
* number of cpus. If deal.II is compiled with multithreading support,
* some functions will use multiple threads for their action, and will
- * use the member variable @p{n_default_threads} of this class as the
+ * use the member variable <tt>n_default_threads</tt> of this class as the
* default number of threads to start. This variable
- * @p{n_default_threads} is set to the number of CPUs by default, but
+ * <tt>n_default_threads</tt> is set to the number of CPUs by default, but
* can be adjusted by the user to fit the requirements.
*
* @author Thomas Richter, 2000
* The number of threads to use as
* a default value for all functions
* that support multithreading.
- * At start time this is @p{n_cpus} or
+ * At start time this is <tt>n_cpus</tt> or
* one, if detection of the number
* of CPUs is not possible.
*/
* 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
/**
- * Global variable of type @p{MultithreadInfo} which you may ask for the
+ * Global variable of type <tt>MultithreadInfo</tt> which you may ask for the
* number of CPUs in you system, as well as for the default number of
* threads that multithreaded functions shall use.
*/
/**
- * The @p{Point} class provides for a point or vector in a space with arbitrary
- * dimension @p{dim}.
+ * The <tt>Point</tt> class provides for a point or vector in a space with arbitrary
+ * dimension <tt>dim</tt>.
*
* It is the preferred object to be passed to functions which
* operate on points in spaces of a priori unknown dimension: rather than
- * using functions like @p{double f(double x)} and @p{double f(double x, double y)},
- * you use double @p{f(Point<dim> &p)}.
+ * using functions like <tt>double f(double x)</tt> and <tt>double f(double x, double y)</tt>,
+ * you use double <tt>f(Point<dim> &p)</tt>.
*
- * @p{Point} also serves as a starting point for the implementation of the
- * geometrical primitives like @p{Polyhedron}, @p{Triangle}, etc.
+ * <tt>Point</tt> also serves as a starting point for the implementation of the
+ * geometrical primitives like <tt>Polyhedron</tt>, <tt>Triangle</tt>, etc.
*
- * @p{Point}s can also be thought of as vectors, i.e. points in a vector space
+ * <tt>Point</tt>s can also be thought of as vectors, i.e. points in a vector space
* without an obvious meaning. For instance, it may be suitable to let the
- * gradient of a function be a @p{point} vector:
- * @p{Point<dim> gradient_of_f (const Point<dim> &x)}. @p{Point}s have all
+ * gradient of a function be a <tt>point</tt> vector:
+ * <tt>Point<dim> gradient_of_f (const Point<dim> &x)</tt>. <tt>Point</tt>s have all
* functionality for this, e.g. scalar products, addition etc. However, you
- * should also consider using the simpler @p{Tensor<1,dim>} class, which seems
+ * should also consider using the simpler <tt>Tensor<1,dim></tt> class, which seems
* more suited to gradients.
*
* @author Wolfgang Bangerth, 1997
/**
* Constructor. Initialize all
* entries to zero if
- * @p{initialize==true}.
+ * <tt>initialize==true</tt>.
*/
explicit Point (const bool initialize);
/**
* Constructor for one dimensional points. This
- * function is only implemented for @p{dim==1}
+ * function is only implemented for <tt>dim==1</tt>
* since the usage is considered unsafe
- * for points with @p{dim!=1}.
+ * for points with <tt>dim!=1</tt>.
*/
explicit Point (const double x);
/**
* Constructor for two dimensional points. This
- * function is only implemented for @p{dim==2}
+ * function is only implemented for <tt>dim==2</tt>
* since the usage is considered unsafe
- * for points with @p{dim!=2}.
+ * for points with <tt>dim!=2</tt>.
*/
Point (const double x, const double y);
/**
* Constructor for three dimensional points. This
- * function is only implemented for @p{dim==3}
+ * function is only implemented for <tt>dim==3</tt>
* since the usage is considered unsafe
- * for points with @p{dim!=3}.
+ * for points with <tt>dim!=3</tt>.
*/
Point (const double x, const double y, const double z);
/**
- * Read access to the @p{index}th coordinate.
+ * Read access to the <tt>index</tt>th coordinate.
*/
double operator () (const unsigned int index) const;
/**
- * Read and write access to the @p{index}th
+ * Read and write access to the <tt>index</tt>th
* coordinate.
*/
double & operator () (const unsigned int index);
/**
* Add two point vectors. If possible, use
- * @p{operator +=} instead since this does not
+ * <tt>operator +=</tt> instead since this does not
* need to copy a point at least once.
*/
Point<dim> operator + (const Tensor<1,dim>&) const;
/**
* Subtract two point vectors. If possible, use
- * @p{operator +=} instead since this does not
+ * <tt>operator +=</tt> instead since this does not
* need to copy a point at least once.
*/
Point<dim> operator - (const Tensor<1,dim>&) const;
/**
* Multiply by a factor. If possible, use
- * @p{operator *=} instead since this does not
+ * <tt>operator *=</tt> instead since this does not
* need to copy a point at least once.
*
* There is a commutative complement to this
/**
* Divide by a factor. If possible, use
- * @p{operator /=} instead since this does not
+ * <tt>operator /=</tt> instead since this does not
* need to copy a point at least once.
*/
Point<dim> operator / (const double) const;
double square () const;
/**
- * Returns the distance of @p{this}
- * point to the point @p{p}.
+ * Returns the distance of <tt>this</tt>
+ * point to the point <tt>p</tt>.
*/
double distance (const Point<dim> &p) const;
* product polynomials then use
* this function, rather than
* using any of the
- * @p{compute_value},
- * @p{compute_grad} or
- * @p{compute_grad_grad}
+ * <tt>compute_value</tt>,
+ * <tt>compute_grad</tt> or
+ * <tt>compute_grad_grad</tt>
* functions, see below, in a
* loop over all tensor product
* polynomials.
/**
* Computes the value of the
- * @p{i}th BDM
+ * <tt>i</tt>th BDM
* polynomial at
- * @p{unit_point}.
+ * <tt>unit_point</tt>.
*
* Note, that using this function
* within a loop over all tensor
* (one-dimensional) polynomials
* is (unnecessarily) computed
* several times. Instead use
- * the @p{compute} function, see
+ * the <tt>compute</tt> function, see
* above, with
- * @p{values.size()==n_tensor_pols}
+ * <tt>values.size()==n_tensor_pols</tt>
* to get the point values of all
* tensor polynomials all at once
* and in a much more efficient
/**
* Computes the grad of the
- * @p{i}th tensor product
+ * <tt>i</tt>th tensor product
* polynomial at
- * @p{unit_point}. Here @p{i} is
+ * <tt>unit_point</tt>. Here <tt>i</tt> is
* given in tensor product
* numbering.
*
* underlying (one-dimensional)
* polynomials is (unnecessarily)
* computed several times.
- * Instead use the @p{compute}
+ * Instead use the <tt>compute</tt>
* function, see above, with
- * @p{grads.size()==n_tensor_pols}
+ * <tt>grads.size()==n_tensor_pols</tt>
* to get the point value of all
* tensor polynomials all at once
* and in a much more efficient
/**
* Computes the second
* derivative (grad_grad) of the
- * @p{i}th tensor product
+ * <tt>i</tt>th tensor product
* polynomial at
- * @p{unit_point}. Here @p{i} is
+ * <tt>unit_point</tt>. Here <tt>i</tt> is
* given in tensor product
* numbering.
*
* underlying (one-dimensional)
* polynomials is (unnecessarily)
* computed several times.
- * Instead use the @p{compute}
+ * Instead use the <tt>compute</tt>
* function, see above, with
- * @p{grad_grads.size()==n_tensor_pols}
+ * <tt>grad_grads.size()==n_tensor_pols</tt>
* to get the point value of all
* tensor polynomials all at once
* and in a much more efficient
/**
* This function returns all
* possible names for quadratures
- * as a list separated by @p{|},
+ * as a list separated by <tt>|</tt>,
* so that you can use it for the
* definition of parameter files
* (see @ref{ParameterHandler} for
* in inner typedef with the
* following semantics: if the
* first template parameter is
- * @p{true}, then the inner
- * typedef is @p{volatile T},
- * otherwise @p{T}. We achieve
+ * <tt>true</tt>, then the inner
+ * typedef is <tt>volatile T</tt>,
+ * otherwise <tt>T</tt>. We achieve
* this behavior by partial
* specialization of the general
* template for both values of
* or not, depending on whether
* we are in multithreaded mode
* or not. (If we are in MT mode,
- * then we need the @p{volatile}
+ * then we need the <tt>volatile</tt>
* specifier since more than one
* thread my modify the counter
* at the same time.
* Since we only partially
* specialize the case that the
* boolean template argument is
- * @p{false}, this general
+ * <tt>false</tt>, this general
* template catches the case that
- * it is @p{true}, i.e. in a
+ * it is <tt>true</tt>, i.e. in a
* sense it is also a
* specialization since a
- * @p{bool} can only have two
+ * <tt>bool</tt> can only have two
* states.
*
* @author Wolfgang Bangerth, 2003
* Specialization of the template
* for the case that the first
* template argument is
- * @p{false}, i.e. the
+ * <tt>false</tt>, i.e. the
* non-volatile case.
*/
template <typename T> struct PossiblyVolatile<false,T>
* constructor by reference, is stored. Then, the original object may
* not be deleted before the dependent object is deleted. You can assert
* this constraint by letting the object passed be derived from this class
- * and let the user @p{subscribe} to this object. The destructor the used
- * object inherits from the @p{Subscriptor} class then will lead to an error
+ * and let the user <tt>subscribe</tt> to this object. The destructor the used
+ * object inherits from the <tt>Subscriptor</tt> class then will lead to an error
* when destruction is attempted while there are still subscriptions.
*/
class Subscriptor
* care, too, because the counter
* has to remain the same. It therefore
* does nothing more than returning
- * @p{*this}.
+ * <tt>*this</tt>.
*/
Subscriptor& operator = (const Subscriptor&);
/**
* Exception: object should be used
- * when @p{unsubscribe} is called.
+ * when <tt>unsubscribe</tt> is called.
*/
DeclException0(ExcNotUsed);
* The creator (and owner) of an
* object is not counted.
*
- * We use the @p{mutable} keyword
+ * We use the <tt>mutable</tt> keyword
* in order to allow subscription
* to constant objects also.
*
* counter may be modified by
* different threads. We thus
* have to mark it
- * @p{volatile}. However, this is
+ * <tt>volatile</tt>. However, this is
* counter-productive in non-MT
* mode since it may pessimize
* code. So use the above
public:
/**
* Access the value of the
- * @p{i}th index.
+ * <tt>i</tt>th index.
*/
unsigned int operator[] (const unsigned int i) const;
*
* This is the general template, and has no implementation. There are
* a number of specializations that are actually implemented (one for
- * each used value of @p{N}), which only differ in the way they
- * implement their constructors (they take @p{N} arguments, something
+ * each used value of <tt>N</tt>), which only differ in the way they
+ * implement their constructors (they take <tt>N</tt> arguments, something
* that cannot be represented by a general template). Actual storage
* of and access to data is done by the @ref{TableIndicesBase} base
* class of a specializations.
/**
* @internal
* Have a namespace in which we declare some classes that are used to
- * access the elements of tables using the @p{operator[]}. These are
+ * access the elements of tables using the <tt>operator[]</tt>. These are
* quite technical, since they have to do their work recursively (due
* to the fact that the number of indices is not known, we have to
* return an iterator into the next lower dimension object if we
* classes at all, except possibly for educational reasons. None of
* the classes herein has a interface that you should use explicitly
* in your programs (except, of course, through access to the elements
- * of tables with @p{operator[]}, which generates temporary objects of
+ * of tables with <tt>operator[]</tt>, which generates temporary objects of
* the types of this namespace).
*
* @author Wolfgang Bangerth, 2002
/**
* @internal
* Class that acts as accessor to subobjects of tables of type
- * @p{Table<N,T>}. The template parameter @p{C} may be either true or
+ * <tt>Table<N,T></tt>. The template parameter <tt>C</tt> may be either true or
* false, and indicates whether the objects worked on are constant or
* not (i.e. write access is only allowed if the value is false).
*
- * Since with @p{N} indices, the effect of applying @p{operator[]} is
- * getting access to something we @p{N-1} indices, we have to
+ * Since with <tt>N</tt> indices, the effect of applying <tt>operator[]</tt> is
+ * getting access to something we <tt>N-1</tt> indices, we have to
* implement these accessor classes recursively, with stopping when we
* have only one index left. For the latter case, a specialization of
- * this class is declared below, where calling @p{operator[]} gives
+ * this class is declared below, where calling <tt>operator[]</tt> gives
* you access to the objects actually stored by the table. In the
* value given to the index operator needs to be checked whether it is
* inside its bounds, for which we need to know which index of the
* table we are actually accessing presently. This is done through the
- * template parameter @p{P}: it indicates, how many remaining indices
- * there are. For a vector, @p{P} may only be one (and then the
+ * template parameter <tt>P</tt>: it indicates, how many remaining indices
+ * there are. For a vector, <tt>P</tt> may only be one (and then the
* specialization below is used). For a table this value may be two,
- * and when using @p{operator[]}, an object with @p{P=1} emerges.
+ * and when using <tt>operator[]</tt>, an object with <tt>P=1</tt> emerges.
*
- * The value of @p{P} is also used to determine the stride: this
+ * The value of <tt>P</tt> is also used to determine the stride: this
* object stores a pointer indicating the beginning of the range of
- * objects that it may access. When we apply @p{operator[]} on this
+ * objects that it may access. When we apply <tt>operator[]</tt> on this
* object, the resulting new accessor may only access a subset of
* these elements, and to know which subset we need to know the
* dimensions of the table and the present index, which is indicated
- * by @p{P}.
+ * by <tt>P</tt>.
*
* As stated for the entire namespace, you will not usually have to do
* with these classes directly, and should not try to use their
* you having such objects
* around. The only way to
* create such objects is via
- * the @p{Table} class, which
+ * the <tt>Table</tt> class, which
* only generates them as
* temporary objects. This
* guarantees that the accessor
* you having such objects
* around. The only way to
* create such objects is via
- * the @p{Table} class, which
+ * the <tt>Table</tt> class, which
* only generates them as
* temporary objects. This
* guarantees that the accessor
* it is two then it is a matrix, and so on.
*
* Previously, this data type was emulated in this library by
- * constructs like @p{std::vector<std::vector<T>>}, or even higher
+ * constructs like <tt>std::vector<std::vector<T>></tt>, or even higher
* nested constructs. However, this has the disadvantage that it is
* hard to initialize, and most importantly that it is very
* inefficient if all rows have the same size (which is the usual
* class. Second, how to access the individual elements. The basic
* problem here is that we would like to make the number of arguments
* to be passed to the constructor as well as the access functions
- * dependent on the template parameter @p{N} indicating the number of
+ * dependent on the template parameter <tt>N</tt> indicating the number of
* dimensions. Of course, this is not possible.
*
* The way out of the first problem (and partly the second one as
- * well) is to have derived class for each value of @p{N} that have a
+ * well) is to have derived class for each value of <tt>N</tt> that have a
* constructor with the right number of arguments, one for each
* dimension. These then transform their arguments into the data type
* this class wants to see, both for construction as well as access
- * through the @p{operator()} function.
+ * through the <tt>operator()</tt> function.
*
* The second problem is that we would like to allow access through a
- * sequence of @p{operator[]} calls. This mostly because, as said,
+ * sequence of <tt>operator[]</tt> calls. This mostly because, as said,
* this class is a replacement for previous use of nested
- * @p{std::vector} objects, where we had to use the @p{operator[]}
+ * <tt>std::vector</tt> objects, where we had to use the <tt>operator[]</tt>
* access function recursively until we were at the innermost
* object. Emulating this behavior without losing the ability to do
* index checks, and in particular without losing performance is
* In some way, this class is similar to the @ref{Tensor} class, in
* that it templatizes on the number of dimensions. However, there are
* two major differences. The first is that the @ref{Tensor} class
- * stores only numeric values (as @p{double}s), while the @p{Table}
+ * stores only numeric values (as <tt>double</tt>s), while the <tt>Table</tt>
* class stores arbitrary objects. The second is that the @ref{Tensor}
* class has fixed dimensions, also give as a template argument, while
* this class can handle arbitrary dimensions, which may also be
/**
* Assignment operator.
- * Copy all elements of @p{src}
+ * Copy all elements of <tt>src</tt>
* into the matrix. The size is
* adjusted if needed.
*
/**
* Copy operator.
- * Copy all elements of @p{src}
+ * Copy all elements of <tt>src</tt>
* into the array. The size is
* adjusted if needed.
*
* This function requires that the
- * type @p{T2} is convertible to
- * @p{T}.
+ * type <tt>T2</tt> is convertible to
+ * <tt>T</tt>.
*/
template<typename T2>
TableBase<N,T>& operator = (const TableBase<N,T2> &src);
* empty, i.e. one of the
* directions is zero. This is
* equivalent to
- * @p{n_elements()==0}.
+ * <tt>n_elements()==0</tt>.
*/
bool empty () const;
* means line by line. No range
* checking is performed, i.e.,
* it is assumed that the input
- * array @p{entries} contains
- * @p{n_rows()*n_cols()}
+ * array <tt>entries</tt> contains
+ * <tt>n_rows()*n_cols()</tt>
* elements, and that the layout
* refers to the desired shape of
* this table. The only check we
*
* Note also that the type of the
* objects of the input array,
- * @p{T2}, must be convertible to
+ * <tt>T2</tt>, must be convertible to
* the type of the objects of
* this array.
*/
* larger than the number of
* actually used elements, since
* we don't shrink the array upon
- * calls to @p{reinit} unless the
+ * calls to <tt>reinit</tt> unless the
* new size is zero.
*/
unsigned int val_size;
* For the rationale of this class, and a description of the
* interface, see the base class. Since this serves as the base class
* of the full matrix classes in this library, and to keep a minimal
- * compatibility with a predecessor class (@p{vector2d}), some
+ * compatibility with a predecessor class (<tt>vector2d</tt>), some
* additional functions are provided.
*
* @author Wolfgang Bangerth, 2002
* Reinitialize the object. This
* function is mostly here for
* compatibility with the earlier
- * @p{vector2d} class. Passes
+ * <tt>vector2d</tt> class. Passes
* down to the base class by
* converting the arguments to
* the data type requested by the
protected:
/**
* Return a read-write reference
- * to the element @p{(i,j)}.
+ * to the element <tt>(i,j)</tt>.
*
* This function does no bounds
* checking and is only to be
* here for compatibility with a
* former implementation of these
* table classes for 2d arrays,
- * then called @p{vector2d}.
+ * then called <tt>vector2d</tt>.
*/
T & el (const unsigned int i,
const unsigned int j);
/**
* Return the value of the
- * element @p{(i,j)} as a
+ * element <tt>(i,j)</tt> as a
* read-only reference.
*
* This function does no bounds
* here for compatibility with a
* former implementation of these
* table classes for 2d arrays,
- * then called @p{vector2d}.
+ * then called <tt>vector2d</tt>.
*/
const T & el (const unsigned int i,
const unsigned int j) const;
/**
* This specialization of the general template for the case of a
- * @p{true} first template argument declares a local typedef @p{type}
+ * <tt>true</tt> first template argument declares a local typedef <tt>type</tt>
* to the second template argument. It is used in order to construct
* constraints on template arguments in template (and member template)
* functions. The negative specialization is missing.
* an arbitrary number of indices. The Tensor class provides an
* indexing operator and a bit of infrastructure, but most
* functionality is recursively handed down to tensors of rank 1 or
- * put into external templated functions, e.g. the @p{contract} family.
+ * put into external templated functions, e.g. the <tt>contract</tt> family.
*
* Using this tensor class for objects of rank 2 has advantages over
* matrices in many cases since the dimension is known to the compiler
* explicit knowledge of it's
* data type. Implementation is
* this way instead of providing
- * a function @p{dimension()}
+ * a function <tt>dimension()</tt>
* because now it is possible to
* get the dimension at compile
* time without the expansion and
Tensor<rank_,dim> & operator -= (const Tensor<rank_,dim> &);
/**
- * Scale the tensor by @p{factor}, i.e. multiply
- * all coordinates by @p{factor}.
+ * Scale the tensor by <tt>factor</tt>, i.e. multiply
+ * all coordinates by <tt>factor</tt>.
*/
Tensor<rank_,dim> & operator *= (const double &factor);
/**
- * Scale the vector by @p{1/factor}.
+ * Scale the vector by <tt>1/factor</tt>.
*/
Tensor<rank_,dim> & operator /= (const double &factor);
/**
* Add two tensors. If possible, use
- * @p{operator +=} instead since this does not
+ * <tt>operator +=</tt> instead since this does not
* need to copy a point at least once.
*/
Tensor<rank_,dim> operator + (const Tensor<rank_,dim> &) const;
/**
* Subtract two tensors. If possible, use
- * @p{operator +=} instead since this does not
+ * <tt>operator +=</tt> instead since this does not
* need to copy a point at least once.
*/
Tensor<rank_,dim> operator - (const Tensor<rank_,dim> &) const;
/**
* Contract a tensor of rank 1 with a tensor of rank 1. The result is
- * @p{sum_j src1[j] src2[j]}.
+ * <tt>sum_j src1[j] src2[j]</tt>.
*
* @author Guido Kanschat, 2000
*/
/**
* Contract a tensor of rank 2 with a tensor of rank 1. The result is
- * @p{dest[i] = sum_j src1[i][j] src2[j]}.
+ * <tt>dest[i] = sum_j src1[i][j] src2[j]</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Contract a tensor of rank 1 with a tensor of rank 2. The result is
- * @p{dest[i] = sum_j src1[j] src2[j][i]}.
+ * <tt>dest[i] = sum_j src1[j] src2[j][i]</tt>.
*
* @author Guido Kanschat, 2001
*/
/**
* Contract a tensor of rank 2 with a tensor of rank 2. The result is
- * @p{dest[i][k] = sum_j src1[i][j] src2[j][k]}.
+ * <tt>dest[i][k] = sum_j src1[i][j] src2[j][k]</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Contract a tensor of rank 2 with a tensor of rank 2. The
- * contraction is performed over index @p{index1} of the first tensor,
- * and @p{index2} of the second tensor. Thus, if @p{index1==2},
- * @p{index2==1}, the result is the usual contraction, but if for
- * example @p{index1==1}, @p{index2==2}, then the result is
- * @p{dest[i][k] = sum_j src1[j][i] src2[k][j]}.
+ * contraction is performed over index <tt>index1</tt> of the first tensor,
+ * and <tt>index2</tt> of the second tensor. Thus, if <tt>index1==2</tt>,
+ * <tt>index2==1</tt>, the result is the usual contraction, but if for
+ * example <tt>index1==1</tt>, <tt>index2==2</tt>, then the result is
+ * <tt>dest[i][k] = sum_j src1[j][i] src2[k][j]</tt>.
*
* Note that the number of the index is counted from 1 on, not from
* zero as usual.
/**
* Contract a tensor of rank 3 with a tensor of rank 1. The
- * contraction is performed over index @p{index1} of the first
+ * contraction is performed over index <tt>index1</tt> of the first
* tensor.
*
* Note that the number of the index is counted from 1 on, not from
/**
* Contract a tensor of rank 3 with a tensor of rank 2. The result is
- * @p{dest[i][j][l] = sum_k src1[i][j][k] src2[k][l]}.
+ * <tt>dest[i][j][l] = sum_k src1[i][j][k] src2[k][l]</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Contract a tensor of rank 2 with a tensor of rank 3. The result is
- * @p{dest[i][j][l] = sum_k src1[i][k] src2[k][j][l]}.
+ * <tt>dest[i][j][l] = sum_k src1[i][k] src2[k][j][l]</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Contract a tensor of rank 3 with a tensor of rank 3. The result is
- * @p{dest[i][j][k][l] = sum_m src1[i][j][m] src2[m][k][l]}.
+ * <tt>dest[i][j][k][l] = sum_m src1[i][j][m] src2[m][k][l]</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
* Form the outer product of two tensors of rank 1 and 1, i.e.
- * @p{dst[i][j] = src1[i] * src2[j]}.
+ * <tt>dst[i][j] = src1[i] * src2[j]</tt>.
*
* @author Wolfgang Bangerth, 2000
*/
/**
* Form the outer product of two tensors of rank 1 and 2, i.e.
- * @p{dst[i][j][k] = src1[i] * src2[j][k]}.
+ * <tt>dst[i][j][k] = src1[i] * src2[j][k]</tt>.
*
* @author Wolfgang Bangerth, 2000
*/
/**
* Form the outer product of two tensors of rank 2 and 1, i.e.
- * @p{dst[i][j][k] = src1[i][j] * src2[k]}.
+ * <tt>dst[i][j][k] = src1[i][j] * src2[k]</tt>.
*
* @author Wolfgang Bangerth, 2000
*/
/**
* Form the outer product of two tensors of rank 0 and 1, i.e.
- * @p{dst[i] = src1 * src2[i]}. Of course, this is only a scaling of
- * @p{src2}, but we consider this an outer product for completeness of
+ * <tt>dst[i] = src1 * src2[i]</tt>. Of course, this is only a scaling of
+ * <tt>src2</tt>, but we consider this an outer product for completeness of
* these functions and since this is sometimes needed when writing
* templates that depend on the rank of a tensor, which may sometimes
* be zero (i.e. a scalar).
/**
* Form the outer product of two tensors of rank 1 and 0, i.e.
- * @p{dst[i] = src1[i] * src2}. Of course, this is only a scaling of
- * @p{src1}, but we consider this an outer product for completeness of
+ * <tt>dst[i] = src1[i] * src2</tt>. Of course, this is only a scaling of
+ * <tt>src1</tt>, but we consider this an outer product for completeness of
* these functions and since this is sometimes needed when writing
* templates that depend on the rank of a tensor, which may sometimes
* be zero (i.e. a scalar).
* vector. This function is defined for all space dimensions to allow
* for dimension independent programming (e.g. within switches over
* the space dimenion), but may only be called if the actual dimension
- * of the arguments is two (e.g. from the @p{dim==2} case in the
+ * of the arguments is two (e.g. from the <tt>dim==2</tt> case in the
* switch).
*
* @author Guido Kanschat, 2001
* space dimensions to allow for dimension independent programming
* (e.g. within switches over the space dimenion), but may only be
* called if the actual dimension of the arguments is three (e.g. from
- * the @p{dim==3} case in the switch).
+ * the <tt>dim==3</tt> case in the switch).
*
* @author Guido Kanschat, 2001
*/
// can be computed by recursion. we
// need therefore not try to access
// the number itself, which is
- // difficult since it needs @p{rank}
+ // difficult since it needs <tt>rank</tt>
// indirections, which is not
// computable in the general
// template
/**
- * Compute the determinant of a tensor or rank 2, here for @p{dim==2}.
+ * Compute the determinant of a tensor or rank 2, here for <tt>dim==2</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
/**
- * Compute the determinant of a tensor or rank 2, here for @p{dim==3}.
+ * Compute the determinant of a tensor or rank 2, here for <tt>dim==3</tt>.
*
* @author Wolfgang Bangerth, 1998
*/
* perform the return value optimization, and since the size of the
* return object is known, it is acceptable to return the result by
* value, rather than by reference as a parameter. Note that there are
- * specializations of this function for @p{dim==1,2,3}.
+ * specializations of this function for <tt>dim==1,2,3</tt>.
*
* @author Wolfgang Bangerth, 2002
*/
/**
* Return the transpose of the given tensor. This is the
- * specialization of the general template for @p{dim==1}.
+ * specialization of the general template for <tt>dim==1</tt>.
*
* @author Wolfgang Bangerth, 2002
*/
/**
* Return the transpose of the given tensor. This is the
- * specialization of the general template for @p{dim==2}.
+ * specialization of the general template for <tt>dim==2</tt>.
*
* @author Wolfgang Bangerth, 2002
*/
/**
* Return the transpose of the given tensor. This is the
- * specialization of the general template for @p{dim==3}.
+ * specialization of the general template for <tt>dim==3</tt>.
*
* @author Wolfgang Bangerth, 2002
*/
// $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
/**
- * This class is a specialized version of the @p{Tensor<rank,dim>} class.
+ * This class is a specialized version of the <tt>Tensor<rank,dim></tt> class.
* It handles tensors with one index, i.e. vectors, of fixed dimension
* and offers the functionality needed for tensors of higher rank.
*
- * In many cases, you will want to use the more specialized @p{Point} class
+ * In many cases, you will want to use the more specialized <tt>Point</tt> class
* which acts as a tensor of rank one but has more functionality.
*/
template <int dim>
* explicit knowledge of it's
* data type. Implementation is
* this way instead of providing
- * a function @p{dimension()}
+ * a function <tt>dimension()</tt>
* because now it is possible to
* get the dimension at compile
* time without the expansion and
* an object of this type.
*
* Avoid warning about zero-sized
- * array for @p{dim==0} by
+ * array for <tt>dim==0</tt> by
* choosing lunatic value that is
* likely to overflow memory
* limits.
/**
* Constructor. Initialize all entries
- * to zero if @p{initialize==true}; this
+ * to zero if <tt>initialize==true</tt>; this
* is the default behaviour.
*/
explicit Tensor (const bool initialize = true);
Tensor (const Tensor<1,dim> &);
/**
- * Read access to the @p{index}th
+ * Read access to the <tt>index</tt>th
* coordinate.
*
* Note that the derived
- * @p{Point} class also provides
- * access through the @p{()}
+ * <tt>Point</tt> class also provides
+ * access through the <tt>()</tt>
* operator for
* backcompatibility.
*/
/**
* Read and write access to the
- * @p{index}th coordinate.
+ * <tt>index</tt>th coordinate.
*
* Note that the derived
- * @p{Point} class also provides
- * access through the @p{()}
+ * <tt>Point</tt> class also provides
+ * access through the <tt>()</tt>
* operator for
* backcompatibility.
*/
/**
* Scale the vector by
- * @p{factor}, i.e. multiply all
- * coordinates by @p{factor}.
+ * <tt>factor</tt>, i.e. multiply all
+ * coordinates by <tt>factor</tt>.
*/
Tensor<1,dim> & operator *= (const double &factor);
/**
- * Scale the vector by @p{1/factor}.
+ * Scale the vector by <tt>1/factor</tt>.
*/
Tensor<1,dim> & operator /= (const double &factor);
/**
* Add two tensors. If possible,
- * use @p{operator +=} instead
+ * use <tt>operator +=</tt> instead
* since this does not need to
* copy a point at least once.
*/
/**
* Subtract two tensors. If
- * possible, use @p{operator +=}
+ * possible, use <tt>operator +=</tt>
* instead since this does not
* need to copy a point at least
* once.
private:
/**
* Store the values in a simple
- * array. For @p{dim==0} store
+ * array. For <tt>dim==0</tt> store
* one element, because otherways
* the compiler would choke. We
* catch this case in the
/**
* Prints the values of this point in the
- * form @p{x1 x2 x3 etc}.
+ * form <tt>x1 x2 x3 etc</tt>.
*/
template <int dim>
std::ostream & operator << (std::ostream &out, const Tensor<1,dim> &p);
+/// @if NoDoc
/*------------------------------- Inline functions: Tensor ---------------------------*/
return tt;
}
-
+/// @endif
#endif
* functions with several components, but that the return type is
* always tensor-valued. The returned values of the evaluation of
* objects of this type are always whole tensors, while for the
- * @p{Function} class, one can ask for a specific component only, or
- * use the @p{vector_value} function, which however does not return
+ * <tt>Function</tt> class, one can ask for a specific component only, or
+ * use the <tt>vector_value</tt> function, which however does not return
* the value, but rather writes it into the address provided by its
* second argument. The reason for the different behaviour of the
* classes is that in the case if tensor valued functions, the size
* the size is not known to the compiler, so memory has to be
* allocated on the heap, resulting in relatively expensive copy
* operations. One can therefore consider this class a specialization
- * of the @p{Function} class for which the size is known. An
+ * of the <tt>Function</tt> class for which the size is known. An
* additional benefit is that tensors of arbitrary rank can be
* returned, not only vectors, as for them the size can be determined
* similarly simply.
public:
/**
* Define typedefs for the return
- * types of the @p{value}
+ * types of the <tt>value</tt>
* functions.
*/
typedef Tensor<rank,dim> value_type;
virtual value_type value (const Point<dim> &p) 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
+ * <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<value_type> &values) const;
virtual gradient_type gradient (const Point<dim> &p) const;
/**
- * Set @p{gradients} to the
+ * Set <tt>gradients</tt> to the
* gradients of the function at
- * the @p{points}. It is assumed
- * that @p{values} already has
+ * 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 gradient_list (const std::vector<Point<dim> > &points,
std::vector<gradient_type> &gradients) const;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* multithreading. It allows to write programs such that they start
* new threads and/or lock objects in multithreading mode, and use
* dummy thread management and synchronisation classes instead when
- * running in single-thread mode. Specifically, the @p{spawn} functions
+ * running in single-thread mode. Specifically, the <tt>spawn</tt> functions
* only call the function but wait for it to return instead of running
* in on another thread, and the mutices do nothing really. The only
* reason to provide such a function is that the program can be
* automatically be the case
* when you lock and unlock the
* mutex "by hand", i.e. using
- * @p{acquire} and @p{release}.
+ * <tt>acquire</tt> and <tt>release</tt>.
*/
class ScopedLock
{
* programs such that they start new threads and/or lock objects in
* multithreading mode, and use dummy thread management and
* synchronisation classes instead when running in single-thread
- * mode. Specifically, the @p{spawn} functions only call the function
+ * mode. Specifically, the <tt>spawn</tt> functions only call the function
* but wait for it to return instead of running in on another thread,
* and the mutices do nothing really. The only reason to provide such
* a function is that the program can be compiled both in MT and
* mutex which needs to be
* given to this function as an
* argument, see the man page
- * of @p{posix_cond_wait} for a
+ * of <tt>posix_cond_wait</tt> for a
* description of the
* mechanisms. Since in single
* threaded mode, this function
* (otherwise, the barrier could not be left, since the one thread is
* waiting for some other part of the program to reach a certain point
* of execution), the constructor of this class throws an exception if
- * the @p{count} argument denoting the number of threads that need to
+ * the <tt>count</tt> argument denoting the number of threads that need to
* be synchronised is not equal to one.
*
* @author Wolfgang Bangerth, 2001
* number of threads to be
* synchronised is one, this
* constructor raises an
- * exception if the @p{count}
+ * exception if the <tt>count</tt>
* argument is one.
*/
DummyBarrier (const unsigned int count,
* automatically be the case
* when you lock and unlock the
* mutex "by hand", i.e. using
- * @p{acquire} and @p{release}.
+ * <tt>acquire</tt> and <tt>release</tt>.
*/
class ScopedLock
{
* condition variables a
* friend, since it needs
* access to the
- * @p{pthread_mutex_t}
+ * <tt>pthread_mutex_t</tt>
* structure.
*/
friend class PosixThreadCondition;
* mutex which needs to be
* given to this function as an
* argument, see the man page
- * of @p{posix_cond_wait} for a
+ * of <tt>posix_cond_wait</tt> for a
* description of the
* mechanisms.
*/
* threads are created by directly
* calling the respective functions
* of the operating system
- * (e.g. @p{pthread_create} for the
+ * (e.g. <tt>pthread_create</tt> for the
* POSIX thread interface), or if
* they are killed (e.g. either
- * through @p{pthread_exit} from
+ * through <tt>pthread_exit</tt> from
* the spawned thread, or
- * @p{pthread_kill} from another
+ * <tt>pthread_kill</tt> from another
* thread), then these events are
* not registered and counted for
* the result of this function.
unsigned int n_existing_threads ();
/**
- * Split the range @p{[begin,end)}
- * into @p{n_intervals} subintervals
+ * Split the range <tt>[begin,end)</tt>
+ * into <tt>n_intervals</tt> subintervals
* of equal size. The last interval
* will be a little bit larger, if
* the number of elements in the
* whole range is not exactly
- * divisible by @p{n_intervals}. The
+ * divisible by <tt>n_intervals</tt>. The
* type of the iterators has to
* fulfill the requirements of a
* forward iterator,
- * i.e. @p{operator++} must be
+ * i.e. <tt>operator++</tt> must be
* available, and of course it must
* be assignable.
*
* returned as a vector of pairs of
* iterators, where each pair
* denotes the range
- * @p{[begin[i],end[i])}.
+ * <tt>[begin[i],end[i])</tt>.
*/
template <typename ForwardIterator>
std::vector<std::pair<ForwardIterator,ForwardIterator> >
const unsigned int n_intervals);
/**
- * Split the interval @p{[begin,end)}
+ * Split the interval <tt>[begin,end)</tt>
* into subintervals of (almost)
* equal size. This function works
* mostly as the one before, with
* points to new threads, we
* therefore install a try-catch
* block, and if an exception of
- * type @p{std::exception} is
+ * type <tt>std::exception</tt> is
* caught, it passes over control
* to this function, which will
* then provide some output.
* @internal
* Same as above, but the type of
* the exception is not derived
- * from @p{std::exception}, so
+ * from <tt>std::exception</tt>, so
* there is little way to provide
* something more useful.
*/
} // end declarations of namespace Threads
-
+/// @if NoDoc
/* ----------- implementation of functions in namespace Threads ---------- */
namespace Threads
{
/**
* Store whether the
- * @p{join()} member function
+ * <tt>join()</tt> member function
* as already been called. If
- * @p{true}, then @p{join}
+ * <tt>true</tt>, then <tt>join</tt>
* will return immediately,
* otherwise it needs to go
* through a call to the
* class. Access to it is
* performed through counted
* pointers, both from
- * @p{Thread<>} objects as
+ * <tt>Thread<></tt> objects as
* well as from the thread
* entry point function on
* the new thread. It is only
/**
* Mutex used to synchronise
- * calls to the @p{join()}
+ * calls to the <tt>join()</tt>
* function.
*/
mutable ThreadMutex join_mutex;
* point and arguments. Store
* the result of the
* operation in the
- * @p{thread} member variable
+ * <tt>thread</tt> member variable
* for further use.
*/
void create (void * (*p) (void *), void *d);
* around in user space.
*
* The default value of the
- * template argument is @p{void},
+ * template argument is <tt>void</tt>,
* so if the function you are
* calling on a new thread has no
* return value, you can omit the
* with a pointer to an
* internal thread object. This
* is the constructor used to
- * the @p{spawn} family of
+ * the <tt>spawn</tt> family of
* functions.
*
* We would like to make this
* constructor private and only
* grant the
- * @p{wrapper_base::fire_up}
+ * <tt>wrapper_base::fire_up</tt>
* function friendship, but
* granting friendship to
* functions in other
* except for assigning it a
* thread object that holds
* data created by the
- * @p{spawn} functions.
+ * <tt>spawn</tt> functions.
*/
Thread () {};
* thread. Since this is only
* available once the thread
* finishes, this implicitely
- * also calls @p{join()}.
+ * also calls <tt>join()</tt>.
*/
RT return_value () {
join ();
* return type of the function
* being called. The second one
* is a class that provides a
- * function @p{entry_point},
+ * function <tt>entry_point</tt>,
* which will be used as an entry
* point for the new thread. In
* the classes derived from this
* not supported, there can
* only be exactly one thread,
* and the result is
- * @p{true}. This function
+ * <tt>true</tt>. This function
* doesn't make much sense,
* though, when threads are not
* supported.
* Overload of the non-const spawn
* function for member functions
* with no arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* no arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the non-const spawn
* function for member functions with
* 1 argument. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function for
* const member functions with 1
* argument. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 2 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 2 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 3 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 3 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 4 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 4 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 5 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 5 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 6 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 6 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 7 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 7 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 8 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 8 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 9 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 9 arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the non-const spawn
* function for member functions
* with 10 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for const member functions with
* 10 arguments. This is the
- * version of the @p{spawn}
+ * version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* for non-member or static member
* functions with no
* arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 1 argument. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 2 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 3 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 4 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 5 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 6 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 7 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 8 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* Overload of the spawn function
* for non-member or static member
* functions with 9 arguments. This
- * is the version of the @p{spawn}
+ * is the version of the <tt>spawn</tt>
* function for the case that
* threading is not enabled.
*/
* for non-member or static member
* functions with 10
* arguments. This is the version
- * of the @p{spawn} function for
+ * of the <tt>spawn</tt> function for
* the case that threading is not
* enabled.
*/
} // end of implementation of namespace Threads
-
+/// @endif
//---------------------------- thread_management.h ---------------------------
* @end{verbatim}
*
* Alternatively, you can also restart the timer instead of resetting
- * it. The times between successive calls to @p{start/stop} will then be
+ * it. The times between successive calls to <tt>start/stop</tt> will then be
* accumulated.
*
* Note: the implementation of this class is system dependent.
private:
/**
- * Value of the user time when @p{start}
+ * Value of the user time when <tt>start</tt>
* was called the last time or when the
- * object was created and no @p{stop} was
+ * object was created and no <tt>stop</tt> was
* issued in between.
*/
double start_time;
/**
- * Similar to @p{start_time}, but
+ * Similar to <tt>start_time</tt>, but
* needed for children threads
* in multithread mode. Value of
- * the user time when @p{start}
+ * the user time when <tt>start</tt>
* was called the last time or
* when the object was created
- * and no @p{stop} was issued in
+ * and no <tt>stop</tt> was issued in
* between.
*
* For some reason (error in
* operating system?) the
* function call
- * @p{getrusage(RUSAGE_CHILDREN,.)}
+ * <tt>getrusage(RUSAGE_CHILDREN,.)</tt>
* gives always 0 (at least
* on Solaris7). Hence the
- * @p{Timer} class still does not
+ * <tt>Timer</tt> class still does not
* yet work for multithreading
* mode.
*/
/**
* Accumulated time for all previous
- * @p{start}/@p{stop} cycles. The time for
+ * <tt>start</tt>/<tt>stop</tt> cycles. The time for
* the present cycle is not included.
*/
double cumulative_time;