]> https://gitweb.dealii.org/ - dealii.git/commitdiff
doc for doxygen; these files need a retouch!
authorGuido Kanschat <dr.guido.kanschat@gmail.com>
Fri, 9 Jan 2004 12:45:56 +0000 (12:45 +0000)
committerGuido Kanschat <dr.guido.kanschat@gmail.com>
Fri, 9 Jan 2004 12:45:56 +0000 (12:45 +0000)
git-svn-id: https://svn.dealii.org/trunk@8298 0785d39b-7218-0410-832d-ea1e28bc413d

18 files changed:
deal.II/base/include/base/function_derivative.h
deal.II/base/include/base/function_lib.h
deal.II/base/include/base/function_time.h
deal.II/base/include/base/job_identifier.h
deal.II/base/include/base/logstream.h
deal.II/base/include/base/memory_consumption.h
deal.II/base/include/base/multithread_info.h
deal.II/base/include/base/point.h
deal.II/base/include/base/polynomials_bdm.h
deal.II/base/include/base/quadrature_selector.h
deal.II/base/include/base/subscriptor.h
deal.II/base/include/base/table.h
deal.II/base/include/base/template_constraints.h
deal.II/base/include/base/tensor.h
deal.II/base/include/base/tensor_base.h
deal.II/base/include/base/tensor_function.h
deal.II/base/include/base/thread_management.h
deal.II/base/include/base/timer.h

index a3cdfcaac39adf55799d45ceaa135fe2ddcb31ca..be5ca3b36aa1540ba1622072c22077c585ffd4e3 100644 (file)
 /**
  * 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
@@ -53,7 +53,7 @@ class FunctionDerivative : public Function<dim>
                                      * 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,
@@ -72,7 +72,7 @@ class FunctionDerivative : public Function<dim>
                                      * 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.
                                      *
@@ -91,11 +91,11 @@ class FunctionDerivative : public Function<dim>
                                      *
                                      * 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);
     
@@ -122,7 +122,7 @@ class FunctionDerivative : public Function<dim>
                                      * 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
index bb78b1f4b34c6f2c1ce1973d5d0562c7f9824d47..49a0cba819f9b66db6b7c6d9dc114b61cbf6d704 100644 (file)
@@ -86,7 +86,7 @@ namespace Functions
   
   
 /**
- * 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
@@ -475,7 +475,7 @@ namespace Functions
  * 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
@@ -546,7 +546,7 @@ namespace Functions
                                        * 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
@@ -573,12 +573,12 @@ namespace Functions
       double angle;
       
                                       /**
-                                       * Sine of @p{angle}.
+                                       * Sine of <tt>angle</tt>.
                                        */
       double sine;
       
                                       /**
-                                       * Cosine of @p{angle}.
+                                       * Cosine of <tt>angle</tt>.
                                        */
       double cosine;
   };
@@ -631,7 +631,7 @@ namespace Functions
       
                                       /**
                                        * 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;
@@ -690,7 +690,7 @@ namespace Functions
       
                                       /**
                                        * 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;
@@ -747,7 +747,7 @@ namespace Functions
       
                                       /**
                                        * 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;
@@ -813,7 +813,7 @@ namespace Functions
       
                                       /**
                                        * 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;
@@ -859,7 +859,7 @@ namespace Functions
                                        * 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
@@ -872,12 +872,12 @@ namespace Functions
       
                                       /**
                                        * 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);
 
@@ -894,7 +894,7 @@ namespace Functions
 
                                       /**
                                        * 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;
@@ -904,8 +904,8 @@ namespace Functions
   
 /**
  * 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]
@@ -923,7 +923,7 @@ namespace Functions
                                        * 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
@@ -957,7 +957,7 @@ namespace Functions
   
 /**
  * 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.
  *
@@ -973,7 +973,7 @@ namespace Functions
                                        * 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.
@@ -1006,8 +1006,8 @@ namespace Functions
   
 /**
  * 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.
  *
@@ -1023,7 +1023,7 @@ namespace Functions
                                        * 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.
index 434c21bb7b9213f4d00a0b68b339339609ccc0dd..54e0ba19e1838bb4e785605a6ff89ef7e055ef18 100644 (file)
  *  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.
  *
  *
@@ -79,14 +79,14 @@ class FunctionTime
     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);
 
index c8ee8639e501ac1a06a0aa145ecd8d26a0969627..e2d4eee55b440678b0e44a4081f3b50421e04156 100644 (file)
@@ -18,9 +18,9 @@
 #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.
  */
@@ -30,7 +30,7 @@ class JobIdentifier
                                     /**
                                      * Constructor. Set program
                                      * identifier to value of
-                                     * @p{program_id} concatenated
+                                     * <tt>program_id</tt> concatenated
                                      * with the present time.
                                      */
     JobIdentifier();
@@ -53,7 +53,7 @@ class JobIdentifier
     static const char* program_id();
 
                                     /**
-                                     * Return the value of @p{id}.
+                                     * Return the value of <tt>id</tt>.
                                      */
     const std::string operator () () const;
     
index b59badcdaf3966c2aefdb4ceb810b7b5a162a569..aa7b22f155d5678522e17205f01b0e12963fc406 100644 (file)
  * @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
@@ -58,27 +58,27 @@ class LogStream
                                     /**
                                      * 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 ();
 
@@ -117,9 +117,9 @@ class LogStream
                                      * 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
@@ -131,7 +131,7 @@ class LogStream
                                      * 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.
@@ -156,11 +156,11 @@ class LogStream
                                      * 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).
@@ -186,10 +186,10 @@ class LogStream
                                      * 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
@@ -206,7 +206,7 @@ class LogStream
                                      * 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
@@ -233,7 +233,7 @@ class LogStream
                                     /**
                                      * 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;
@@ -244,7 +244,7 @@ class LogStream
                                      * 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;
 
@@ -304,7 +304,7 @@ class LogStream
                                      * 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);
@@ -336,7 +336,7 @@ LogStream::operator<< (std::ostream& (*p) (std::ostream&))
   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)
@@ -353,7 +353,7 @@ void
 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)
     {
index 544e02745a27328c70c76392833c3f4410f4d86d..53c8d6378409ee6ce45025ba8591dd1b0c4e88e1 100644 (file)
@@ -2,7 +2,7 @@
 //    $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
@@ -85,7 +85,7 @@ namespace MemoryConsumption
 {
                                   /**
                                    * Determine the amount of memory
-                                   * in bytes consumed by a @p{bool}
+                                   * in bytes consumed by a <tt>bool</tt>
                                    * variable.
                                    */
   inline
@@ -93,7 +93,7 @@ namespace MemoryConsumption
 
                                   /**
                                    * Determine the amount of memory
-                                   * in bytes consumed by a @p{char}
+                                   * in bytes consumed by a <tt>char</tt>
                                    * variable.
                                    */
   inline
@@ -102,7 +102,7 @@ namespace MemoryConsumption
                                   /**
                                    * 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);
@@ -110,14 +110,14 @@ namespace MemoryConsumption
                                   /**
                                    * 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
@@ -125,7 +125,7 @@ namespace MemoryConsumption
 
                                   /**
                                    * Determine the amount of memory
-                                   * in bytes consumed by a @p{unsigned int}
+                                   * in bytes consumed by a <tt>unsigned int</tt>
                                    * variable.
                                    */
   inline
@@ -133,7 +133,7 @@ namespace MemoryConsumption
 
                                   /**
                                    * Determine the amount of memory
-                                   * in bytes consumed by a @p{float}
+                                   * in bytes consumed by a <tt>float</tt>
                                    * variable.
                                    */
   inline
@@ -141,7 +141,7 @@ namespace MemoryConsumption
 
                                   /**
                                    * Determine the amount of memory
-                                   * in bytes consumed by a @p{double}
+                                   * in bytes consumed by a <tt>double</tt>
                                    * variable.
                                    */
   inline
@@ -150,7 +150,7 @@ namespace MemoryConsumption
                                   /**
                                    * 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
@@ -159,16 +159,16 @@ namespace MemoryConsumption
                                   /**
                                    * 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
@@ -213,12 +213,12 @@ namespace MemoryConsumption
                                    * 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.
                                    */
@@ -230,7 +230,7 @@ namespace MemoryConsumption
                                    * 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
@@ -244,7 +244,7 @@ namespace MemoryConsumption
                                    * 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);
@@ -253,7 +253,7 @@ namespace MemoryConsumption
                                    * 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);
@@ -262,7 +262,7 @@ namespace MemoryConsumption
                                    * 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);
@@ -271,7 +271,7 @@ namespace MemoryConsumption
                                    * 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);
@@ -280,7 +280,7 @@ namespace MemoryConsumption
                                    * 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);
@@ -357,10 +357,10 @@ namespace MemoryConsumption
                                    * 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
@@ -372,7 +372,7 @@ namespace MemoryConsumption
                                    * 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
@@ -387,6 +387,8 @@ namespace MemoryConsumption
 
 // now comes the implementation of these functions
 
+/// @if NoDoc
+
 namespace MemoryConsumption
 {
   inline
@@ -596,6 +598,6 @@ namespace MemoryConsumption
   }
 }
 
-
+/// @endif
 
 #endif
index e99b25bd9878b3cee50081270376b40abfeb2e9a..f30e48285dc00ac0c32074df1f870cce823362c3 100644 (file)
@@ -24,9 +24,9 @@
  * 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
@@ -60,7 +60,7 @@ class MultithreadInfo
                                      * 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.
                                      */
@@ -75,7 +75,7 @@ class MultithreadInfo
                                      * 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
@@ -107,7 +107,7 @@ class MultithreadInfo
 
 
 /**
- * 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.
  */
index ad8f3933e6d1ab1935761a8c72a0f3bda26bfa42..5f44f0297e986ba26ed62a536b4d944b201bd70f 100644 (file)
 
 
 /**
- * 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
@@ -55,7 +55,7 @@ class Point : public Tensor<1,dim>
                                     /**
                                      * Constructor. Initialize all
                                      * entries to zero if
-                                     * @p{initialize==true}.
+                                     * <tt>initialize==true</tt>.
                                      */
     explicit Point (const bool initialize);
 
@@ -68,35 +68,35 @@ class Point : public Tensor<1,dim>
     
                                     /**
                                      *  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);
@@ -108,14 +108,14 @@ class Point : public Tensor<1,dim>
                                         
                                     /**
                                      *  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;
@@ -127,7 +127,7 @@ class Point : public Tensor<1,dim>
     
                                     /**
                                      *  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
@@ -142,7 +142,7 @@ class Point : public Tensor<1,dim>
 
                                     /**
                                      *  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;
@@ -155,8 +155,8 @@ class Point : public Tensor<1,dim>
     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;
 
index 1d5381a84b2fdd79d339b48296b7bd4419b20dba..26fa58d8b46db69aa7b8977724219df9f0e91e40 100644 (file)
@@ -74,9 +74,9 @@ class PolynomialsBDM
                                      * 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.
@@ -88,9 +88,9 @@ class PolynomialsBDM
     
                                     /**
                                      * 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
@@ -100,9 +100,9 @@ class PolynomialsBDM
                                      * (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
@@ -113,9 +113,9 @@ class PolynomialsBDM
 
                                     /**
                                      * 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.
                                      *
@@ -127,9 +127,9 @@ class PolynomialsBDM
                                      * 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
@@ -141,9 +141,9 @@ class PolynomialsBDM
                                     /**
                                      * 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.
                                      *
@@ -155,9 +155,9 @@ class PolynomialsBDM
                                      * 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
index f54a3e31ec9619b06ba036b6bafb5d944637c619..c5966f6ae1a0c48d03162606a88a8ee8d49b35fc 100644 (file)
@@ -51,7 +51,7 @@ class QuadratureSelector : public Quadrature<dim>
                                     /**
                                      * 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
index d7cc86303a16fcae4be7d63b7a2c8ba3a09371b5..91b3562aae3c2ad9c5a1ee20a218b66984ad3a8c 100644 (file)
@@ -35,9 +35,9 @@ namespace internal
                                       * 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
@@ -49,7 +49,7 @@ namespace internal
                                       * 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.
@@ -57,12 +57,12 @@ namespace internal
                                       * 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
@@ -77,7 +77,7 @@ namespace internal
                                       * 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>
@@ -97,8 +97,8 @@ namespace internal
  * 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
@@ -131,7 +131,7 @@ 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&);
         
@@ -168,7 +168,7 @@ class Subscriptor
 
                                     /**
                                      * Exception: object should be used
-                                     * when @p{unsubscribe} is called.
+                                     * when <tt>unsubscribe</tt> is called.
                                      */
     DeclException0(ExcNotUsed);
 
@@ -187,7 +187,7 @@ class Subscriptor
                                      * 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.
                                      *
@@ -195,7 +195,7 @@ class Subscriptor
                                      * 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
index 690303dd3ceaa8f99d9afc8eeed5ceb4b5212121..9096721050214876a6fb820232b122073c230cea 100644 (file)
@@ -47,7 +47,7 @@ template <typename T> class Table<6,T>;
     public:
                                        /**
                                         * Access the value of the
-                                        * @p{i}th index.
+                                        * <tt>i</tt>th index.
                                         */
       unsigned int operator[] (const unsigned int i) const;
     
@@ -65,8 +65,8 @@ template <typename T> class Table<6,T>;
  *
  * 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.
@@ -278,7 +278,7 @@ namespace internal
 /**
  * @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
@@ -288,7 +288,7 @@ namespace internal
  * 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
@@ -335,31 +335,31 @@ namespace internal
 /**
  * @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
@@ -396,7 +396,7 @@ namespace internal
                                           * 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
@@ -529,7 +529,7 @@ namespace internal
                                           * 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
@@ -640,7 +640,7 @@ namespace internal
  * 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
@@ -656,20 +656,20 @@ namespace internal
  * 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
@@ -682,7 +682,7 @@ namespace internal
  * 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
@@ -744,7 +744,7 @@ class TableBase : public Subscriptor
     
                                      /**
                                       * Assignment operator.
-                                      * Copy all elements of @p{src}
+                                      * Copy all elements of <tt>src</tt>
                                       * into the matrix. The size is
                                       * adjusted if needed.
                                       *
@@ -758,13 +758,13 @@ class TableBase : public Subscriptor
     
                                      /**
                                       * 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);
@@ -806,7 +806,7 @@ class TableBase : public Subscriptor
                                       * 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;
     
@@ -820,8 +820,8 @@ class TableBase : public Subscriptor
                                       * 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
@@ -830,7 +830,7 @@ class TableBase : public Subscriptor
                                       *
                                       * 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.
                                       */
@@ -926,7 +926,7 @@ class TableBase : public Subscriptor
                                       * 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;    
@@ -1043,7 +1043,7 @@ class Table<1,T> : public TableBase<1,T>
  * 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
@@ -1070,7 +1070,7 @@ class Table<2,T> : public TableBase<2,T>
                                       * 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
@@ -1150,7 +1150,7 @@ class Table<2,T> : public TableBase<2,T>
   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
@@ -1161,14 +1161,14 @@ class Table<2,T> : public TableBase<2,T>
                                       * 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
@@ -1188,7 +1188,7 @@ class Table<2,T> : public TableBase<2,T>
                                       * 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;
index 3b0298e706874d3d80afff279557e1ebc5ef622c..8388d61956557d0e98463ba7e6340e1422950a11 100644 (file)
@@ -22,7 +22,7 @@ template <bool, typename> struct constraint_and_return_value;
 
 /**
  * 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.
index b39b5ee528d8751402730721d5cbaa5a92791be9..7a1cee97bf519061f4008e29f1f1731eb3a994cd 100644 (file)
@@ -25,7 +25,7 @@ template <int dim> class Tensor<1,dim>;
  * 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
@@ -43,7 +43,7 @@ class Tensor
                                      * 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
@@ -125,26 +125,26 @@ class Tensor
     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;
@@ -431,7 +431,7 @@ std::ostream & operator << (std::ostream &out, const Tensor<rank_,1> &p)
 
 /**
  * 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
  */
@@ -450,7 +450,7 @@ double contract (const Tensor<1,dim> &src1,
 
 /**
  * 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
  */
@@ -470,7 +470,7 @@ void contract (Tensor<1,dim>       &dest,
 
 /**
  * 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
  */
@@ -490,7 +490,7 @@ void contract (Tensor<1,dim>       &dest,
 
 /**
  * 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
  */
@@ -511,11 +511,11 @@ void contract (Tensor<2,dim>       &dest,
 
 /**
  * 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.
@@ -584,7 +584,7 @@ void contract (Tensor<2,dim>       &dest,
 
 /**
  * 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
@@ -633,7 +633,7 @@ void contract (Tensor<2,dim>       &dest,
 
 /**
  * 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
  */
@@ -655,7 +655,7 @@ void contract (Tensor<3,dim>       &dest,
 
 /**
  * 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
  */
@@ -676,7 +676,7 @@ void contract (Tensor<3,dim>       &dest,
 
 /**
  * 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
  */
@@ -699,7 +699,7 @@ void contract (Tensor<4,dim>       &dest,
 
 /**
  * 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
  */
@@ -717,7 +717,7 @@ void outer_product (Tensor<2,dim>       &dst,
 
 /**
  * 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
  */
@@ -736,7 +736,7 @@ void outer_product (Tensor<3,dim>       &dst,
 
 /**
  * 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
  */
@@ -755,8 +755,8 @@ void outer_product (Tensor<3,dim>       &dst,
 
 /**
  * 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).
@@ -776,8 +776,8 @@ void outer_product (Tensor<1,dim>       &dst,
 
 /**
  * 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).
@@ -801,7 +801,7 @@ void outer_product (Tensor<1,dim>       &dst,
  * 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
@@ -825,7 +825,7 @@ cross_product (Tensor<1,dim>       &dst,
  * 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
  */
@@ -861,7 +861,7 @@ double determinant (const Tensor<rank,1> &t)
                                   // 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
@@ -886,7 +886,7 @@ double determinant (const Tensor<1,1> &t)
 
 
 /**
- * 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
  */
@@ -901,7 +901,7 @@ double determinant (const Tensor<2,2> &t)
 
 
 /**
- * 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
  */
@@ -1011,7 +1011,7 @@ invert (const Tensor<2,dim> &t)
  * 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
  */
@@ -1035,7 +1035,7 @@ transpose (const Tensor<2,dim> &t)
 
 /**
  * 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
  */
@@ -1051,7 +1051,7 @@ transpose (const Tensor<2,1> &t)
 
 /**
  * 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
  */
@@ -1068,7 +1068,7 @@ transpose (const Tensor<2,2> &t)
 
 /**
  * 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
  */
index 1e0429ff47b21380e2e9eab2328eb0b4fd43a089..336848bf1298e4134e27ac893a6715a580b3a07a 100644 (file)
@@ -2,7 +2,7 @@
 //    $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
@@ -42,11 +42,11 @@ template <int dim> class Tensor<1,dim>;
 
 
 /**
- * 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>
@@ -59,7 +59,7 @@ class Tensor<1,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
@@ -91,7 +91,7 @@ class Tensor<1,dim>
                                      * 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.
@@ -100,7 +100,7 @@ class Tensor<1,dim>
     
                                     /**
                                      * 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);
@@ -118,12 +118,12 @@ class Tensor<1,dim>
     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.
                                      */
@@ -131,11 +131,11 @@ class Tensor<1,dim>
 
                                     /**
                                      * 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.
                                      */
@@ -172,13 +172,13 @@ class Tensor<1,dim>
 
                                     /**
                                      * 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);
 
@@ -190,7 +190,7 @@ class Tensor<1,dim>
 
                                     /**
                                      * 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.
                                      */
@@ -198,7 +198,7 @@ class Tensor<1,dim>
 
                                     /**
                                      * 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.
@@ -244,7 +244,7 @@ class Tensor<1,dim>
   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
@@ -297,11 +297,12 @@ class Tensor<1,dim>
 
                                 /**
                                  *  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 ---------------------------*/
 
@@ -614,7 +615,7 @@ operator / (const Tensor<1,dim> &t,
   return tt;
 }
 
-
+/// @endif
 
 #endif
 
index d1fc171c5b6692514fe9b4d1ce2d15f5240f1f34..fa9c0bd32ae1c54848c4de1b08f9caf62e5195fb 100644 (file)
@@ -32,8 +32,8 @@
  *  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
@@ -43,7 +43,7 @@
  *  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.
@@ -57,7 +57,7 @@ class TensorFunction : public FunctionTime,
   public:
                                     /**
                                      * Define typedefs for the return
-                                     * types of the @p{value}
+                                     * types of the <tt>value</tt>
                                      * functions.
                                      */
     typedef Tensor<rank,dim> value_type;
@@ -130,12 +130,12 @@ class TensorFunction : public FunctionTime,
     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;
@@ -147,12 +147,12 @@ class TensorFunction : public FunctionTime,
     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;
index 858a0f71451a87c02ed8c148b30373461a55b3e8..dd3c4b86f04f848315b28956b7467f2672f75723 100644 (file)
@@ -2,7 +2,7 @@
 //    $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
@@ -44,7 +44,7 @@ namespace Threads
  * 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
@@ -86,7 +86,7 @@ namespace Threads
                                         * 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
       {
@@ -135,7 +135,7 @@ namespace Threads
  * 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
@@ -179,7 +179,7 @@ namespace Threads
                                        * 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
@@ -201,7 +201,7 @@ namespace Threads
  * (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
@@ -216,7 +216,7 @@ namespace Threads
                                        * 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,
@@ -292,7 +292,7 @@ namespace Threads
                                         * 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
       {
@@ -355,7 +355,7 @@ namespace Threads
                                         * condition variables a
                                         * friend, since it needs
                                         * access to the
-                                        * @p{pthread_mutex_t}
+                                        * <tt>pthread_mutex_t</tt>
                                         * structure.
                                         */
       friend class PosixThreadCondition;
@@ -411,7 +411,7 @@ namespace Threads
                                        * 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.
                                        */
@@ -575,12 +575,12 @@ namespace Threads
                                     * 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.
@@ -588,17 +588,17 @@ namespace Threads
   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.
                                    *
@@ -606,7 +606,7 @@ namespace Threads
                                    * 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> >
@@ -615,7 +615,7 @@ namespace Threads
               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
@@ -671,7 +671,7 @@ namespace Threads
                                       * 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.
@@ -682,7 +682,7 @@ namespace Threads
                                      * @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.
                                       */
@@ -715,7 +715,7 @@ namespace Threads
   
 }   // end declarations of namespace Threads
 
-
+/// @if NoDoc
 /* ----------- implementation of functions in namespace Threads ---------- */
 namespace Threads 
 {  
@@ -2807,9 +2807,9 @@ 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
@@ -2823,7 +2823,7 @@ namespace Threads
                                           * 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
@@ -2836,7 +2836,7 @@ namespace Threads
 
                                          /**
                                           * Mutex used to synchronise
-                                          * calls to the @p{join()}
+                                          * calls to the <tt>join()</tt>
                                           * function.
                                           */
         mutable ThreadMutex   join_mutex;
@@ -2859,7 +2859,7 @@ namespace Threads
                                           * 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);
@@ -2913,7 +2913,7 @@ namespace Threads
                                     * 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
@@ -2929,13 +2929,13 @@ namespace Threads
                                         * 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
@@ -2959,7 +2959,7 @@ namespace Threads
                                         * except for assigning it a
                                         * thread object that holds
                                         * data created by the
-                                        * @p{spawn} functions.
+                                        * <tt>spawn</tt> functions.
                                         */
       Thread () {};
 
@@ -2984,7 +2984,7 @@ namespace Threads
                                         * 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 ();
@@ -3044,7 +3044,7 @@ namespace Threads
                                       * 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
@@ -4965,7 +4965,7 @@ namespace Threads
                                         * 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.
@@ -5073,7 +5073,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5089,7 +5089,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5141,7 +5141,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5157,7 +5157,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5212,7 +5212,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5228,7 +5228,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5283,7 +5283,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5300,7 +5300,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5358,7 +5358,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5375,7 +5375,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5435,7 +5435,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5454,7 +5454,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5515,7 +5515,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5534,7 +5534,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5598,7 +5598,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5620,7 +5620,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5688,7 +5688,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5712,7 +5712,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5784,7 +5784,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5808,7 +5808,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5881,7 +5881,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5907,7 +5907,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -5969,7 +5969,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6019,7 +6019,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6071,7 +6071,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6124,7 +6124,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6180,7 +6180,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6238,7 +6238,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6297,7 +6297,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6358,7 +6358,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6423,7 +6423,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6492,7 +6492,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6563,7 +6563,7 @@ namespace Threads
                                     * 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.
                                     */
@@ -6642,7 +6642,7 @@ namespace Threads
   
 }   // end of implementation of namespace Threads
 
-
+/// @endif
 
 
 //----------------------------   thread_management.h     ---------------------------
index 427b025ff9eed862b321819fb7efdd7e1f194422..d373e92e2ec4a1a8837056ec3360a2b984ad32c6 100644 (file)
@@ -44,7 +44,7 @@
  * @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.
@@ -92,31 +92,31 @@ class Timer
   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.
                                      */
@@ -124,7 +124,7 @@ class Timer
 
                                     /**
                                      * 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;

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.