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
* 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
* @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
* <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
* 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:
* 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
* 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.
* 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
* 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
* 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
* <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
* 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
// $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
{
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);
/**
* 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
/**
* 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.
/**
* 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
/**
* 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
/**
* 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.
*
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
* 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
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.
*/
/**
- * 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
*/
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
/**
- * 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.
* 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
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);
* 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.
*
// $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
/**
- * 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
/**
- * 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
*/
/**
- * 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)
* std::ofstream out_file("number_table.tex");
* table.write_tex(out_file);
* out_file.close();
- * @end{verbatim}
+ * @endcode
*
* @author Ralf Hartmann, 1999
*/
/**
* 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,
* 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
* 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.
* 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.
*/
/**
* 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.
*/
/**
* 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.
*/
/**
* 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");
* 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;
* 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.
*/
unsigned int precision;
/**
- * @p{scientific}=false means
+ * <tt>scientific</tt>=false means
* fixed point notation.
*/
bool scientific;
* 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;
* 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;
* 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.
* 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;
};