]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Doc for doxygen
authorGuido Kanschat <dr.guido.kanschat@gmail.com>
Fri, 9 Jan 2004 12:45:21 +0000 (12:45 +0000)
committerGuido Kanschat <dr.guido.kanschat@gmail.com>
Fri, 9 Jan 2004 12:45:21 +0000 (12:45 +0000)
git-svn-id: https://svn.dealii.org/trunk@8297 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/base/include/base/parameter_handler.h
deal.II/base/include/base/polynomial.h
deal.II/base/include/base/table_handler.h

index 0ef677ecbfc887df3fb27102272b8890b4c00694..d618160a489104c13b82f4ce169e4f7bf2d4b20d 100644 (file)
@@ -304,8 +304,8 @@ namespace Patterns
     public:
                                       /**
                                        * Minimal double value. If the
-                                       * @ref numeric_limits class is
-                                       * available use this
+                                       * <tt>std::numeric_limits</tt>
+                                       * class is available use this
                                        * information to obtain the
                                        * extremal values, otherwise
                                        * set it so that this class
@@ -754,7 +754,7 @@ namespace Patterns
  *   structure.
  *
  *   
- *   @section Declaration Declaration of entries
+ *   @section ParameterHandlerDeclaration Declaration of entries
  *   
  *   In order to use the facilities of a ParameterHandler object, one first has
  *   to make known the different entries the input file may or may not contain. This
@@ -847,7 +847,7 @@ namespace Patterns
  *   @endcode
  *
  *
- *   @section Input Input files and special characters
+ *   @section ParameterHandlerInput Input files and special characters
  *
  *   For the first example above the input file would look like the following:
  *   @verbatim
@@ -877,7 +877,7 @@ namespace Patterns
  *   <tt>=</tt> sign.
  *
  *   
- *   @section Reading Reading data from input sources
+ *   @section ParameterHandlerReading Reading data from input sources
  *   
  *   In order to read input you can use three possibilities: reading from an <tt>std::istream</tt> object,
  *   reading from a file of which the name is given and reading from a string in memory in
@@ -907,7 +907,7 @@ namespace Patterns
  *   written to <tt>std::cerr</tt>.
  *
  *   
- *   @section Access Getting entry values out of a ParameterHandler object
+ *   @section ParameterHandlerAccess Getting entry values out of a ParameterHandler object
  *   
  *   Each class gets its data out of a ParameterHandler object by
  *   calling the get()  member functions like this:
@@ -946,7 +946,7 @@ namespace Patterns
  *   input file.
  *   
  *   
- *   @section Style Style guide for data retrieval
+ *   @section ParameterHandlerStyle Style guide for data retrieval
  *   
  *   We propose that every class which gets data out of a
  *   ParameterHandler object provides a function named
@@ -955,7 +955,7 @@ namespace Patterns
  *   should call the <tt>BaseClass::get_parameters</tt> function.
  *
  *
- *   @section Large Experience with large parameter lists
+ *   @section ParameterHandlerLarge Experience with large parameter lists
  *  
  *   Experience has shown that in programs defining larger numbers of parameters (more than,
  *   say, fifty) it is advantageous to define an additional class holding these parameters.
@@ -969,7 +969,7 @@ namespace Patterns
  *   up your main class with dozens or more variables denoting the parameters.
  *
  *
- *   @section Future Possible future extensions
+ *   @section ParameterHandlerFuture Possible future extensions
  *   
  *   <ul>
  *   <li> Allow long input lines to be broken by appending a backslash character
@@ -1698,7 +1698,7 @@ class ParameterHandler
  *   program.
  *
  *   
- *   @section Usage Usage
+ *   @section ParameterHandlerUsage Usage
  *   
  *   The usage of this class is similar to the ParameterHandler class. First the
  *   entries and subsections have to be declared, then a loop is performed in which
@@ -1788,7 +1788,7 @@ class ParameterHandler
  *   run.
  *
  *   
- *   @section Syntax Syntax for variant and array entry values
+ *   @section ParameterHandlerUsageSyntax Syntax for variant and array entry values
  *   
  *   Variant values are specified like <tt>prefix{ v1 | v2 | v3 | ... }postfix</tt>. Whitespace
  *   to the right of the opening brace <tt>{</tt> is ignored as well as to the left of the
@@ -1801,7 +1801,7 @@ class ParameterHandler
  *   <tt>prefix{{ v1 | v2 | v3 }}postfix</tt>.
  *   
  *
- *   @section Example Worked example
+ *   @section ParameterHandlerExample Worked example
  *   
  *   Given the above extensions to the example program for the ParameterHandler and the
  *   following input file
@@ -1863,7 +1863,7 @@ class ParameterHandler
  *   the number of the run.
  *   
  *   
- *   @section References References
+ *   @section ParameterHandlerReferences References
  *   This class is inspired by the <tt>Multipleloop</tt> class of <tt>DiffPack</tt>.
  *
  *   @author Wolfgang Bangerth, October 1997
index 5d6312aed4f000674d9f55ac3b2f74f639fbee7e..439788cf1c3447ec8522a38ce7df695dcb86aed3 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
@@ -43,18 +43,20 @@ namespace Polynomials
   {
     public:
                                        /**
-                                        * Constructor. The coefficients
-                                        * of the polynomial are passed
-                                        * as arguments, and denote the
-                                        * polynomial @p{\sum_i a[i]
-                                        * x^i}, i.e. the first element
+                                        * Constructor. The
+                                        * coefficients of the
+                                        * polynomial are passed as
+                                        * arguments, and denote the
+                                        * polynomial $\sum_i a[i]
+                                        * x^i$, i.e. the first element
                                         * of the array denotes the
-                                        * constant term, the second the
-                                        * linear one, and so on. The
-                                        * degree of the polynomial
-                                        * represented by this object is
-                                        * thus the number of elements in
-                                        * the @p{coefficient} array
+                                        * constant term, the second
+                                        * the linear one, and so
+                                        * on. The degree of the
+                                        * polynomial represented by
+                                        * this object is thus the
+                                        * number of elements in the
+                                        * <tt>coefficient</tt> array
                                         * minus one.
                                         */
       Polynomial (const std::vector<number> &coefficients);
@@ -77,10 +79,10 @@ namespace Polynomials
                                        /**
                                         * Return the values and the
                                         * derivatives of the
-                                        * @p{Polynomial} at point @p{x}.
-                                        * @p{values[i],
-                                        * i=0,...,values.size()-1}
-                                        * includes the @p{i}th
+                                        * Polynomial at point <tt>x</tt>.
+                                        * <tt>values[i],
+                                        * i=0,...,values.size()-1</tt>
+                                        * includes the <tt>i</tt>th
                                         * derivative. The number of
                                         * derivatives to be computed is
                                         * thus determined by the size of
@@ -107,11 +109,11 @@ namespace Polynomials
                                        /**
                                         * Scale the abscissa of the
                                         * polynomial.  Given the
-                                        * polynomial $p(t)$ and the
-                                        * scaling $t = ax$, then the
+                                        * polynomial <i>p(t)</i> and the
+                                        * scaling <i>t = ax</i>, then the
                                         * result of this operation is
-                                        * the polynomial $q$, such that
-                                        * $q(x) = p(t)$.
+                                        * the polynomial <i>q</i>, such that
+                                        * <i>q(x) = p(t)</i>.
                                         *
                                         * The operation is performed in
                                         * place.
@@ -121,24 +123,24 @@ namespace Polynomials
                                        /**
                                         * Shift the abscissa oft the
                                         * polynomial.  Given the
-                                        * polynomial $p(t)$ and the
-                                        * shift $t = x + a$, then the
+                                        * polynomial <i>p(t)</i> and the
+                                        * shift <i>t = x + a</i>, then the
                                         * result of this operation is
-                                        * the polynomial $q$, such that
-                                        * $q(x) = p(t)$.
+                                        * the polynomial <i>q</i>, such that
+                                        * <i>q(x) = p(t)</i>.
                                         *
                                         * The template parameter allows
                                         * to compute the new
                                         * coefficients with higher
                                         * accuracy, since all
                                         * computations are performed
-                                        * with type @p{number2}. This
+                                        * with type <tt>number2</tt>. This
                                         * may be necessary, since this
                                         * operation involves a big
                                         * number of additions. On a Sun
                                         * Sparc Ultra with Solaris 2.8,
                                         * the difference between
-                                        * @p{double} and @p{long double}
+                                        * <tt>double</tt> and <tt>long double</tt>
                                         * was not significant, though.
                                         *
                                         * The operation is performed in
@@ -249,13 +251,13 @@ namespace Polynomials
                                        /**
                                         * Return a vector of Monomial
                                         * objects of orders zero
-                                        * through @p{degree}, which
+                                        * through <tt>degree</tt>, which
                                         * then spans the full space of
                                         * polynomials up to the given
                                         * degree. This function may be
                                         * used to initialize the
-                                        * @ref{TensorProductPolynomials}
-                                        * and @ref{PolynomialSpace}
+                                        * TensorProductPolynomials
+                                        * and PolynomialSpace
                                         * classes.
                                         */
       static
@@ -273,17 +275,17 @@ namespace Polynomials
 
 /**
  * Lagrange polynomials with equidistant interpolation points in
- * [0,1]. The polynomial of degree @p{n} has got @p{n+1} interpolation
+ * [0,1]. The polynomial of degree <tt>n</tt> has got <tt>n+1</tt> interpolation
  * points. The interpolation points are sorted in ascending
  * order. This order gives an index to each interpolation point.  A
  * Lagrangian polynomial equals to 1 at its `support point', and 0 at
  * all other interpolation points. For example, if the degree is 3,
  * and the support point is 1, then the polynomial represented by this
- * object is cubic and its value is 1 at the point @p{x=1/3}, and zero
- * at the point @p{x=0}, @p{x=2/3}, and @p{x=1}. All the polynomials
- * have polynomial order equal to @p{degree}, but together they span
+ * object is cubic and its value is 1 at the point <tt>x=1/3</tt>, and zero
+ * at the point <tt>x=0</tt>, <tt>x=2/3</tt>, and <tt>x=1</tt>. All the polynomials
+ * have polynomial order equal to <tt>degree</tt>, but together they span
  * the entire space of polynomials of degree less than or equal
- * @p{degree}.
+ * <tt>degree</tt>.
  *
  * The Lagrange polynomials are implemented up to degree 10.
  *
@@ -294,19 +296,19 @@ namespace Polynomials
     public:
                                        /**
                                         * Constructor. Takes the order
-                                        * @p{n} of the Lagrangian
+                                        * <tt>n</tt> of the Lagrangian
                                         * polynom and the index
-                                        * @p{support_point} of the
+                                        * <tt>support_point</tt> of the
                                         * support point. Fills the
-                                        * @p{coefficients} of the base
-                                        * class @p{Polynomial}.
+                                        * <tt>coefficients</tt> of the base
+                                        * class Polynomial.
                                         */
       LagrangeEquidistant (const unsigned int n,
                            const unsigned int support_point);
 
                                        /**
                                         * Return a vector of polynomial
-                                        * objects of order @p{degree},
+                                        * objects of order <tt>degree</tt>,
                                         * which then spans the full
                                         * space of polynomials up to the
                                         * given degree. The polynomials
@@ -314,10 +316,10 @@ namespace Polynomials
                                         * constructor of this class with
                                         * the same degree but support
                                         * point running from zero to
-                                        * @p{degree}. This function may
+                                        * <tt>degree</tt>. This function may
                                         * be used to initialize the
-                                        * @ref{TensorProductPolynomials}
-                                        * and @ref{PolynomialSpace}
+                                        * TensorProductPolynomials
+                                        * and PolynomialSpace
                                         * classes.
                                         */
       static
@@ -327,10 +329,10 @@ namespace Polynomials
     private:
 
                                        /**
-                                        * Computes the @p{coefficients}
+                                        * Computes the <tt>coefficients</tt>
                                         * of the base class
-                                        * @p{Polynomial}. This function
-                                        * is @p{static} to allow to be
+                                        * Polynomial. This function
+                                        * is <tt>static</tt> to allow to be
                                         * called in the
                                         * constructor.
                                         */
@@ -342,14 +344,14 @@ namespace Polynomials
 
 
 /**
- * Legendre polynomials of arbitrary order on @p{[0,1]}.
+ * Legendre polynomials of arbitrary order on <tt>[0,1]</tt>.
  *
- * Constructing a Legendre polynomial of order @p{k}, the coefficients
+ * Constructing a Legendre polynomial of order <tt>k</tt>, the coefficients
  * will be computed by the three-term recursion formula.  The
  * coefficients are stored in a static data vector to be available
  * when needed next time. Since the recursion is performed for the
  * interval $[-1,1]$, the polynomials are shifted to $[0,1]$ by the
- * @p{scale} and @p{shift} functions of @p{Polynomial}, afterwards.
+ * <tt>scale</tt> and <tt>shift</tt> functions of <tt>Polynomial</tt>, afterwards.
  *
  * @author Guido Kanschat, 2000
  */
@@ -358,20 +360,20 @@ namespace Polynomials
     public:
                                        /**
                                         * Constructor for polynomial of
-                                        * order @p{k}.
+                                        * order <tt>k</tt>.
                                         */
       Legendre (const unsigned int k);
 
                                        /**
                                         * Return a vector of Legendre
                                         * polynomial objects of orders
-                                        * zero through @p{degree}, which
+                                        * zero through <tt>degree</tt>, which
                                         * then spans the full space of
                                         * polynomials up to the given
                                         * degree. This function may be
                                         * used to initialize the
-                                        * @ref{TensorProductPolynomials}
-                                        * and @ref{PolynomialSpace}
+                                        * TensorProductPolynomials
+                                        * and PolynomialSpace
                                         * classes.
                                         */
       static
@@ -415,9 +417,9 @@ namespace Polynomials
 
 
 /**
- * Hierarchical polynomials of arbitrary order on @p{[0,1]}.
+ * Hierarchical polynomials of arbitrary order on <tt>[0,1]</tt>.
  *
- * When Constructing a Hierarchical polynomial of order @p{k}
+ * When Constructing a Hierarchical polynomial of order <tt>k</tt>
  * the coefficients will be computed by a recursion formula.  The
  * coefficients are stored in a static data vector to be available
  * when needed next time.
@@ -436,20 +438,20 @@ namespace Polynomials
  * polynomials in any way, although better conditioning of the 
  * element stiffness matrix could possibly be achieved with scaling.
  *
- * Calling the constructor with a given index @p{p} will generate the
- * following: if @p{p==0}, then the resulting polynomial is the linear
- * function associated with the left vertex, if @p{p==1} the one
- * associated with the right vertex. For higher values of @p{p}, you
- * get the polynomial of degree @p{p} that is orthogonal to all
- * previous ones. Note that for @p{p==0} you therefore do @em{not}
+ * Calling the constructor with a given index <tt>p</tt> will generate the
+ * following: if <tt>p==0</tt>, then the resulting polynomial is the linear
+ * function associated with the left vertex, if <tt>p==1</tt> the one
+ * associated with the right vertex. For higher values of <tt>p</tt>, you
+ * get the polynomial of degree <tt>p</tt> that is orthogonal to all
+ * previous ones. Note that for <tt>p==0</tt> you therefore do <b>not</b>
  * get a polynomial of degree zero, but one of degree one. This is to
  * allow generating a complete basis for polynomial spaces, by just
  * iterating over the indices given to the constructor.
  *
- * On the other hand, the function @p{generate_complete_basis} creates
+ * On the other hand, the function generate_complete_basis() creates
  * a complete basis of given degree. In order to be consistent with
  * the concept of a polynomial degree, if the given argument is zero,
- * it does @em{not} return the linear polynomial described above, but
+ * it does <b>not</b> return the linear polynomial described above, but
  * rather a constant polynomial.
  *
  * @author Brian Carnes, 2002
@@ -459,8 +461,8 @@ namespace Polynomials
     public:
                                      /**
                                      * Constructor for polynomial of
-                                     * order @p{p}. There is an
-                                     * exception for @p{p==0}, see
+                                     * order <tt>p</tt>. There is an
+                                     * exception for <tt>p==0</tt>, see
                                      * the general documentation.
                                      */
       Hierarchical (const unsigned int p);
@@ -469,11 +471,11 @@ namespace Polynomials
                                      * Return a vector of
                                      * Hierarchical polynomial
                                      * objects of orders zero through
-                                     * @p{degree}, which then spans
+                                     * <tt>degree</tt>, which then spans
                                      * the full space of polynomials
                                      * up to the given degree. Note
                                      * that there is an exception if
-                                     * the given @p{degree} equals
+                                     * the given <tt>degree</tt> equals
                                      * zero, see the general
                                      * documentation of this class.
                                      *
index 0cebb6f1b5df7d2a3bdf33d8e4bd723c0654d8ea..42e3ae616c806ddb7d6022708ec7fa13d79e019a 100644 (file)
@@ -2,7 +2,7 @@
 //    $Id$
 //    Version: $Name$
 //
-//    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by the deal.II authors
+//    Copyright (C) 1998, 1999, 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
@@ -33,7 +33,7 @@
 
 
 /**
- * Abstract base class for the @p{TableEntry} class. See there.
+ * Abstract base class for the <tt>TableEntry</tt> class. See there.
  * This class is not to be used by the user.
  *
  * @author Ralf Hartmann, 1999
@@ -64,13 +64,13 @@ class TableEntryBase
 
 
 /**
- * A @p{TableEntry} stores the value of a table entry.
+ * A <tt>TableEntry</tt> stores the value of a table entry.
  * The value type of this table entry is arbitrary. For
- * a @p{TableEntry<typename value_type>} with a non-common value
+ * a <tt>TableEntry<typename value_type></tt> with a non-common value
  * type you may want to specialize the output functions in order
  * to get nicer output. This class is not to be used by the user.
  *
- * For more detail see the @p{TableHandler} class.
+ * For more detail see the <tt>TableHandler</tt> class.
  *
  * @author Ralf Hartmann, 1999
  */
@@ -114,41 +114,40 @@ class TableEntry : public TableEntryBase
 
 
 /**
- * The @p{TableHandler} stores @p{TableEntries} of arbitrary value
+ * The TableHandler stores TableEntries of arbitrary value
  * type and writes the table as text or in tex format to an output
  * stream. The value type actually may vary from column to column and
  * from row to row.
  *
- * @sect3{Usage}
+ * @section TableHandlerUsage Usage
  *
  * The most important function is the templatized function
- * @p{add_value(const std::string &key, const value_type value)}, that
- * adds a column with the name @p{key} to the table if this column
- * does not yet exist and adds the value of @p{value_type}
- * (e.g. @p{unsigned int}, @p{double}, @p{std::string}, ...) to this
+ * add_value(const std::string &key, const value_type value), that
+ * adds a column with the name <tt>key</tt> to the table if this column
+ * does not yet exist and adds the value of <tt>value_type</tt>
+ * (e.g. <tt>unsigned int</tt>, <tt>double</tt>, <tt>std::string</tt>, ...) to this
  * column.  After the table is complete there are different
  * possibilities of output, e.g.  into a tex file with
- * @p{write_tex(std::ofstream &file)} or as text with @p{write_text
- * (std::ostream &out)}.
+ * write_tex() or as text with write_text().
  *
  * Two (or more) columns may be merged into a "supercolumn" by twice
- * (or multiple) calling @p{add_column_to_supercolumn(...)}, see
+ * (or multiple) calling add_column_to_supercolumn(), see
  * there. Additionally there is a function to set for each column the
  * precision of the output of numbers, and there are several functions
  * to prescribe the format and the captions the columns are written
  * with in tex mode.
  *
- * @sect3{Example}
+ * @section TableHandlerExample Example
  * 
  * This is a simple example demonstrating the usage of this class. The
- * first column includes the numbers @p{i=1..n}, the second
+ * first column includes the numbers <tt>i=1..n</tt>, the second
  * $1^2$...$n^2$, the third $sqrt(1)...sqrt(n)$, where the second and
  * third columns are merged into one supercolumn with the superkey
- * @p{squares and roots}. Additionally the first column is aligned to
- * the right (the default was @p{centered}) and the precision of the
+ * <tt>squares and roots</tt>. Additionally the first column is aligned to
+ * the right (the default was <tt>centered</tt>) and the precision of the
  * square roots are set to be 6 (instead of 4 as default).
  *
- * @begin{verbatim}
+ * @code
  * TableHandler table();
  *
  * for (unsigned int i=1; i<=n; ++i)
@@ -169,7 +168,7 @@ class TableEntry : public TableEntryBase
  * std::ofstream out_file("number_table.tex");
  * table.write_tex(out_file);
  * out_file.close();
- * @end{verbatim}
+ * @endcode
  *
  * @author Ralf Hartmann, 1999
  */
@@ -184,9 +183,9 @@ class TableHandler
     
                                      /**
                                       * Adds a column (if not yet
-                                      * existent) with the key @p{key}
+                                      * existent) with the key <tt>key</tt>
                                       * and adds the value of
-                                      * @p{value_type} to the column.
+                                      * <tt>value_type</tt> to the column.
                                       */
     template <typename value_type>
     void add_value (const std::string &key,
@@ -197,13 +196,13 @@ class TableHandler
                                       * yet existent) and includes
                                       * column to it.  The keys of the
                                       * column and the supercolumn are
-                                      * @p{key} and @p{superkey},
+                                      * <tt>key</tt> and <tt>superkey</tt>,
                                       * respectively.  To merge two
-                                      * columns @p{c1} and @p{c2} to a
-                                      * supercolumn @p{sc} hence call
-                                      * @p{add_column_to_supercolumn(c1,sc)}
+                                      * columns <tt>c1</tt> and <tt>c2</tt> to a
+                                      * supercolumn <tt>sc</tt> hence call
+                                      * <tt>add_column_to_supercolumn(c1,sc)</tt>
                                       * and
-                                      * @p{add_column_to_supercolumn(c2,sc)}.
+                                      * <tt>add_column_to_supercolumn(c2,sc)</tt>.
                                       *
                                       * Concerning the order of the
                                       * columns, the supercolumn
@@ -221,7 +220,7 @@ class TableHandler
                                       * Change the order of columns and
                                       * supercolumns in the table.
                                       *
-                                      * @p{new_order} includes the
+                                      * <tt>new_order</tt> includes the
                                       * keys and superkeys of the
                                       * columns and supercolumns in
                                       * the order the user like to.
@@ -240,28 +239,28 @@ class TableHandler
                                       * many columns into smaller
                                       * ones. Call this function with
                                       * the first e.g. five columns
-                                      * and then @p{write_*}.
+                                      * and then <tt>write_*</tt>.
                                       * Afterwards call this function
                                       * with the next e.g. five
-                                      * columns and again @p{write_*},
+                                      * columns and again <tt>write_*</tt>,
                                       * and so on.
                                       */
     void set_column_order (const std::vector<std::string> &new_order);
     
                                      /**
-                                      * Sets the @p{precision}
+                                      * Sets the <tt>precision</tt>
                                       * e.g. double or float variables
                                       * are written
-                                      * with. @p{precision} is the
+                                      * with. <tt>precision</tt> is the
                                       * same as in calling
-                                      * @p{out<<setprecision(precision)}.
+                                      * <tt>out<<setprecision(precision)</tt>.
                                       */
     void set_precision (const std::string &key,
                         const unsigned int precision);
 
                                      /**
                                       * Sets the
-                                      * @p{scientific_flag}. True
+                                      * <tt>scientific_flag</tt>. True
                                       * means scientific, false means
                                       * fixed point notation.
                                       */
@@ -270,9 +269,9 @@ class TableHandler
 
                                      /**
                                       * Sets the caption of the column
-                                      * @p{key} for tex output. You
+                                      * <tt>key</tt> for tex output. You
                                       * may want to chose this
-                                      * different from @p{key}, if it
+                                      * different from <tt>key</tt>, if it
                                       * contains formulas or similar
                                       * constructs.
                                       */
@@ -281,10 +280,10 @@ class TableHandler
 
                                      /**
                                       * Sets the caption the the
-                                      * supercolumn @p{superkey} for
+                                      * supercolumn <tt>superkey</tt> for
                                       * tex output. You may want to
                                       * chose this different from
-                                      * @p{superkey}, if it contains
+                                      * <tt>superkey</tt>, if it contains
                                       * formulas or similar
                                       * constructs.
                                       */
@@ -293,12 +292,12 @@ class TableHandler
 
                                      /**
                                       * Sets the tex output format of
-                                      * a column, e.g. @p{c}, @p{r},
-                                      * @p{l}, or @p{p{3cm}}. The
-                                      * default is @p{c}. Also if this
+                                      * a column, e.g. <tt>c</tt>, <tt>r</tt>,
+                                      * <tt>l</tt>, or <tt>p{3cm</tt>}. The
+                                      * default is <tt>c</tt>. Also if this
                                       * function is not called for a
                                       * column, the default is preset
-                                      * to be @p{c}.
+                                      * to be <tt>c</tt>.
                                       */
     void set_tex_format (const std::string &key,
                          const std::string &format="c");
@@ -380,11 +379,11 @@ class TableHandler
                                           * actually be of very
                                           * different type, since we
                                           * use the templated
-                                          * @p{TableEntry<T>} class
+                                          * <tt>TableEntry<T></tt> class
                                           * for actual values, which
                                           * is only a wrapper for
-                                          * @p{T}, but is derived from
-                                          * @p{TableEntryBase}.
+                                          * <tt>T</tt>, but is derived from
+                                          * <tt>TableEntryBase</tt>.
                                           */
         std::vector<TableEntryBase *> entries;
        
@@ -393,21 +392,21 @@ class TableHandler
                                           * in tex output.  By
                                           * default, this is the key
                                           * string that is given to
-                                          * the @p{TableHandler} by
-                                          * @p{TableHandler::add_value(...)}. This
+                                          * the <tt>TableHandler</tt> by
+                                          * <tt>TableHandler::add_value(...)</tt>. This
                                           * may be changed by calling
-                                          * @p{TableHandler::set_tex_caption(...)}.
+                                          * <tt>TableHandler::set_tex_caption(...)</tt>.
                                           */
         std::string tex_caption;
 
                                          /**
                                           * The column format in tex
                                           * output.  By default, this
-                                          * is @p{"c"}, meaning
+                                          * is <tt>"c"</tt>, meaning
                                           * `centered'. This may be
                                           * changed by calling
-                                          * @p{TableHandler::set_tex_format(...)}
-                                          * with @p{"c", "r", "l"} for
+                                          * <tt>TableHandler::set_tex_format(...)</tt>
+                                          * with <tt>"c", "r", "l"</tt> for
                                           * centered, right or left.
                                           */
        
@@ -422,7 +421,7 @@ class TableHandler
         unsigned int precision;
 
                                          /**
-                                          * @p{scientific}=false means
+                                          * <tt>scientific</tt>=false means
                                           * fixed point notation.
                                           */
         bool scientific;
@@ -439,14 +438,14 @@ class TableHandler
                                       * Help function that gives a
                                       * vector of the keys of all
                                       * columns that are mentioned in
-                                      * @p{column_order}, where each
+                                      * <tt>column_order</tt>, where each
                                       * supercolumn key is replaced by
                                       * its subcolumn keys.
                                       *
                                       * This function implicitly
                                       * checks the consistency of the
                                       * data. The result is returned
-                                      * in @p{sel_columns}.
+                                      * in <tt>sel_columns</tt>.
                                       */
     void get_selected_columns (std::vector<std::string> &sel_columns) const;
     
@@ -468,7 +467,7 @@ class TableHandler
                                       * default this is the order of
                                       * adding the columns. This order
                                       * may be changed by
-                                      * @p{set_column_order(...)}.
+                                      * <tt>set_column_order(...)</tt>.
                                       */
     std::vector<std::string> column_order;
 
@@ -485,7 +484,7 @@ class TableHandler
                                       * allowed that a supercolumn has
                                       * got the same key as a column.
                                       *
-                                      * Note that we do not use a @p{multimap}
+                                      * Note that we do not use a <tt>multimap</tt>
                                       * here since the order of column
                                       * keys for each supercolumn key is
                                       * relevant.
@@ -501,7 +500,7 @@ class TableHandler
                                       * By default these are just the
                                       * supercolumn keys but they may
                                       * be changed by
-                                      * @p{set_tex_supercaptions(...)}.
+                                      * <tt>set_tex_supercaptions(...)</tt>.
                                       */
     std::map<std::string, std::string> tex_supercaptions;
 };

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.