From 584179ef76c4df0896512b9fb48aaa07f0aae838 Mon Sep 17 00:00:00 2001 From: Guido Kanschat Date: Fri, 9 Jan 2004 12:45:56 +0000 Subject: [PATCH] doc for doxygen; these files need a retouch! git-svn-id: https://svn.dealii.org/trunk@8298 0785d39b-7218-0410-832d-ea1e28bc413d --- .../base/include/base/function_derivative.h | 24 ++-- deal.II/base/include/base/function_lib.h | 42 +++--- deal.II/base/include/base/function_time.h | 24 ++-- deal.II/base/include/base/job_identifier.h | 8 +- deal.II/base/include/base/logstream.h | 50 +++---- .../base/include/base/memory_consumption.h | 96 +++++++------ deal.II/base/include/base/multithread_info.h | 10 +- deal.II/base/include/base/point.h | 50 +++---- deal.II/base/include/base/polynomials_bdm.h | 30 ++-- .../base/include/base/quadrature_selector.h | 2 +- deal.II/base/include/base/subscriptor.h | 28 ++-- deal.II/base/include/base/table.h | 78 +++++----- .../base/include/base/template_constraints.h | 2 +- deal.II/base/include/base/tensor.h | 72 +++++----- deal.II/base/include/base/tensor_base.h | 41 +++--- deal.II/base/include/base/tensor_function.h | 24 ++-- deal.II/base/include/base/thread_management.h | 136 +++++++++--------- deal.II/base/include/base/timer.h | 18 +-- 18 files changed, 369 insertions(+), 366 deletions(-) diff --git a/deal.II/base/include/base/function_derivative.h b/deal.II/base/include/base/function_derivative.h index a3cdfcaac3..be5ca3b36a 100644 --- a/deal.II/base/include/base/function_derivative.h +++ b/deal.II/base/include/base/function_derivative.h @@ -21,14 +21,14 @@ /** * 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 b is the + * vector, the derivative b . grad f is computed. This derivative + * is evaluated directly, not by computing the gradient of f and + * its scalar product with b. * * 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 set_formula for available + * schemes). Experimenting with h and the difference scheme may be * necessary to obtain sufficient results. * * @author Guido Kanschat, 2000 @@ -53,7 +53,7 @@ class FunctionDerivative : public Function * functions to compute * derivatives of, the direction * vector of the differentiation - * and the step size @p{h} of the + * and the step size h of the * difference formula. */ FunctionDerivative (const Function &f, @@ -72,7 +72,7 @@ class FunctionDerivative : public Function * This is the constructor for a * variable velocity field. Most * probably, a new object of - * @p{FunctionDerivative} has to + * FunctionDerivative has to * be constructed for each set of * quadrature points. * @@ -91,11 +91,11 @@ class FunctionDerivative : public Function * * Formulas implemented right now * are first order backward Euler - * (@p{UpwindEuler}), second + * (UpwindEuler), second * order symmetric Euler - * (@p{Euler}) and a symmetric + * (Euler) and a symmetric * fourth order formula - * (@p{FourthOrder}). + * (FourthOrder). */ void set_formula (DifferenceFormula formula = Euler); @@ -122,7 +122,7 @@ class FunctionDerivative : public Function * not be determined exactly * (for example: what is the * memory consumption of an - * STL @p{std::map} type with a + * STL std::map type with a * certain number of * elements?), this is only * an estimate. however often diff --git a/deal.II/base/include/base/function_lib.h b/deal.II/base/include/base/function_lib.h index bb78b1f4b3..49a0cba819 100644 --- a/deal.II/base/include/base/function_lib.h +++ b/deal.II/base/include/base/function_lib.h @@ -86,7 +86,7 @@ namespace Functions /** - * The function @p{xy}. This function serves as an example for + * The function xy. 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 + * -atan(sx), where s 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 std::map 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 angle. */ double sine; /** - * Cosine of @p{angle}. + * Cosine of angle. */ double cosine; }; @@ -631,7 +631,7 @@ namespace Functions /** * Compute the Laplacian of a - * given component at point @p{p}. + * given component at point p. */ virtual double laplacian (const Point &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 p. */ virtual double laplacian (const Point &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 p. */ virtual double laplacian (const Point &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 p. */ virtual double laplacian (const Point &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 select 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 p. */ void new_center (const Point& p); /** - * Set the radius of the ball to @p{r}. + * Set the radius of the ball to r. */ void new_radius (const double r); @@ -894,7 +894,7 @@ namespace Functions /** * Component selected. If - * @p{no_component}, the function is + * no_component, 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 center + * with a specified radius, 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 select 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 radius around center. 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 select 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 radius + * around center, $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 select is * given, the cut-off function * will be non-zero for this * component only. diff --git a/deal.II/base/include/base/function_time.h b/deal.II/base/include/base/function_time.h index 434c21bb7b..54e0ba19e1 100644 --- a/deal.II/base/include/base/function_time.h +++ b/deal.II/base/include/base/function_time.h @@ -26,33 +26,33 @@ * 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 ZeroFunction, ConstantFunction 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 get_time: return the present value of the time variable. + * @item set_time: set the time value to a specific value. + * @item advance_time: 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 sin(t), 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 set_time, store it in a member variable and use that one + * rather than computing it every time operator(), value_list or one * of the other functions is called. * - * By default, the @p{advance_time} function calls the @p{set_time} function + * By default, the advance_time function calls the set_time function * with the new time, so it is sufficient in most cases to overload only - * @p{set_time} for computations as sketched out above. + * set_time 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 time 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 new_time, 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 delta_t. */ virtual void advance_time (const double delta_t); diff --git a/deal.II/base/include/base/job_identifier.h b/deal.II/base/include/base/job_identifier.h index c8ee8639e5..e2d4eee55b 100644 --- a/deal.II/base/include/base/job_identifier.h +++ b/deal.II/base/include/base/job_identifier.h @@ -18,9 +18,9 @@ #include /** - * Identification of a program run. @p{JobIdentifier} determines the + * Identification of a program run. JobIdentifier 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 dealjobid 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 + * program_id 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 id. */ const std::string operator () () const; diff --git a/deal.II/base/include/base/logstream.h b/deal.II/base/include/base/logstream.h index b59badcdaf..aa7b22f155 100644 --- a/deal.II/base/include/base/logstream.h +++ b/deal.II/base/include/base/logstream.h @@ -39,15 +39,15 @@ * @end{itemize} * * The usual usage of this class is through the pregenerated object - * @p{deallog}. Typical steps are + * deallog. 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 deallog.attach(std::ostream): write logging information into a file. + * @item deallog.depth_console(n): 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}. + * deallog.push("loopname"). + * @item deallog << anything << std::endl; to write logging information + * (Usage of std::endl is mandatory!). + * @item deallog.pop() when leaving that stage entered with push. * @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}. + * deallog in the library. Set the + * standard output stream to std::cerr. */ LogStream (); /** * Enable output to a second - * stream @p{o}. + * stream o. */ void attach (std::ostream& o); /** * Disable output to the second * stream. You may want to call - * @p{close} on the stream that was + * close on the stream that was * previously attached to this object. */ void detach (); /** - * Gives the default stream (@p{std_out}). + * Gives the default stream (std_out). */ 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 n * prefixes is printed. By calling - * this function with @p{n=0}, no + * this function with n=0, 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, + * depth_console, 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 + * true, the time difference * between the previous log line * and the recent one is * printed. If it is invoked with - * @p{false}, the accumulated + * false, 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 std::endl * manipulator, for which special * action is performed: set the - * @p{was_endl} variable that + * was_endl 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 std::map 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 std::cerr, 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 attach 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. + * operator<< functions. */ template 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 + // endl 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 + // std::endl, print the topmost // prefix and a colon if (was_endl) { diff --git a/deal.II/base/include/base/memory_consumption.h b/deal.II/base/include/base/memory_consumption.h index 544e02745a..53c8d63784 100644 --- a/deal.II/base/include/base/memory_consumption.h +++ b/deal.II/base/include/base/memory_consumption.h @@ -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 @@ -25,52 +25,52 @@ * 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 std::map<> 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 int or double) or STL containers (such + * as vectors). The method goes as follows: if the object with + * which a memory_consumption function from this namespace is an + * atomic type, the return its size by applying the sizeof * 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++ std::vector, * 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 >} to its atomic + * memory_consumption on each of them. This way, we can also + * reduce objects of type std::vector > 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)}, to the sizes + * subobjects: for C++ std::vector objects, we also have to add the + * size of the vector object, i.e. sizeof(vector), to the sizes * of the elements. Secondly, for the most common used vectors, such - * as @p{std::vector} and @p{std::vector} we determine the + * as std::vector and std::vector 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 T 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 + * T::memory_consumption 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}, 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 memory_consumption(v) on a vector v of type + * FullMatrix, we first reduce this to a loop in which we + * call memory_consumption(v[i]), and because there is no such * function handling this explicitly, we try to call - * @p{v[i].memory_consumption()}. + * v[i].memory_consumption(). * * * @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 + * memory_consumption(T) in this namespace determining the amount + * of memory use by objects of type T, or that the class T 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 bool * 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 char * variable. */ inline @@ -102,7 +102,7 @@ namespace MemoryConsumption /** * Determine the amount of memory * in bytes consumed by a - * @p{short int} variable. + * short int 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. + * short unsigned int 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 int * 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 unsigned int * 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 float * 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 double * 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 std::string * 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 std::vector of * certain elements. It does so by * looping over all elements of the * vector and determining their * sizes using the - * @p{memory_consumption} + * memory_consumption * functions. If the elements are * of constant size, there might be * another global function - * @p{memory_consumption} for this + * memory_consumption 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 doubles in such * arrays (but rather use STL - * @p{std::vector}s or deal.II - * @p{Vector} objects), we do not + * std::vectors or deal.II + * Vector objects), we do not * provide specializations like - * for the @p{std::vector} arrays, but + * for the std::vector 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 bools. * * 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 ints. */ inline unsigned int memory_consumption (const std::vector &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 doubles. */ inline unsigned int memory_consumption (const std::vector &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 floats. */ inline unsigned int memory_consumption (const std::vector &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 chars. */ inline unsigned int memory_consumption (const std::vector &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 unsigned chars. */ inline unsigned int memory_consumption (const std::vector &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 void is no + * type and a void* is thus * not caught by the general - * @p{T*} template function + * T* 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 + * memory_consumption. 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 diff --git a/deal.II/base/include/base/multithread_info.h b/deal.II/base/include/base/multithread_info.h index e99b25bd98..f30e48285d 100644 --- a/deal.II/base/include/base/multithread_info.h +++ b/deal.II/base/include/base/multithread_info.h @@ -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 n_default_threads 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 + * n_default_threads 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 n_cpus 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 std::map 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 MultithreadInfo 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. */ diff --git a/deal.II/base/include/base/point.h b/deal.II/base/include/base/point.h index ad8f3933e6..5f44f0297e 100644 --- a/deal.II/base/include/base/point.h +++ b/deal.II/base/include/base/point.h @@ -21,23 +21,23 @@ /** - * The @p{Point} class provides for a point or vector in a space with arbitrary - * dimension @p{dim}. + * The Point class provides for a point or vector in a space with arbitrary + * dimension dim. * * 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 &p)}. + * using functions like double f(double x) and double f(double x, double y), + * you use double f(Point &p). * - * @p{Point} also serves as a starting point for the implementation of the - * geometrical primitives like @p{Polyhedron}, @p{Triangle}, etc. + * Point also serves as a starting point for the implementation of the + * geometrical primitives like Polyhedron, Triangle, etc. * - * @p{Point}s can also be thought of as vectors, i.e. points in a vector space + * Points 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 gradient_of_f (const Point &x)}. @p{Point}s have all + * gradient of a function be a point vector: + * Point gradient_of_f (const Point &x). Points 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 Tensor<1,dim> 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}. + * initialize==true. */ 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 dim==1 * since the usage is considered unsafe - * for points with @p{dim!=1}. + * for points with dim!=1. */ explicit Point (const double x); /** * Constructor for two dimensional points. This - * function is only implemented for @p{dim==2} + * function is only implemented for dim==2 * since the usage is considered unsafe - * for points with @p{dim!=2}. + * for points with dim!=2. */ 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 dim==3 * since the usage is considered unsafe - * for points with @p{dim!=3}. + * for points with dim!=3. */ Point (const double x, const double y, const double z); /** - * Read access to the @p{index}th coordinate. + * Read access to the indexth coordinate. */ double operator () (const unsigned int index) const; /** - * Read and write access to the @p{index}th + * Read and write access to the indexth * 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 + * operator += instead since this does not * need to copy a point at least once. */ Point operator + (const Tensor<1,dim>&) const; /** * Subtract two point vectors. If possible, use - * @p{operator +=} instead since this does not + * operator += instead since this does not * need to copy a point at least once. */ Point 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 + * operator *= 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 + * operator /= instead since this does not * need to copy a point at least once. */ Point 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 this + * point to the point p. */ double distance (const Point &p) const; diff --git a/deal.II/base/include/base/polynomials_bdm.h b/deal.II/base/include/base/polynomials_bdm.h index 1d5381a84b..26fa58d8b4 100644 --- a/deal.II/base/include/base/polynomials_bdm.h +++ b/deal.II/base/include/base/polynomials_bdm.h @@ -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} + * compute_value, + * compute_grad or + * compute_grad_grad * 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 + * ith BDM * polynomial at - * @p{unit_point}. + * unit_point. * * 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 compute function, see * above, with - * @p{values.size()==n_tensor_pols} + * values.size()==n_tensor_pols * 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 + * ith tensor product * polynomial at - * @p{unit_point}. Here @p{i} is + * unit_point. Here i 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 compute * function, see above, with - * @p{grads.size()==n_tensor_pols} + * grads.size()==n_tensor_pols * 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 + * ith tensor product * polynomial at - * @p{unit_point}. Here @p{i} is + * unit_point. Here i 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 compute * function, see above, with - * @p{grad_grads.size()==n_tensor_pols} + * grad_grads.size()==n_tensor_pols * to get the point value of all * tensor polynomials all at once * and in a much more efficient diff --git a/deal.II/base/include/base/quadrature_selector.h b/deal.II/base/include/base/quadrature_selector.h index f54a3e31ec..c5966f6ae1 100644 --- a/deal.II/base/include/base/quadrature_selector.h +++ b/deal.II/base/include/base/quadrature_selector.h @@ -51,7 +51,7 @@ class QuadratureSelector : public Quadrature /** * This function returns all * possible names for quadratures - * as a list separated by @p{|}, + * as a list separated by |, * so that you can use it for the * definition of parameter files * (see @ref{ParameterHandler} for diff --git a/deal.II/base/include/base/subscriptor.h b/deal.II/base/include/base/subscriptor.h index d7cc86303a..91b3562aae 100644 --- a/deal.II/base/include/base/subscriptor.h +++ b/deal.II/base/include/base/subscriptor.h @@ -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 + * true, then the inner + * typedef is volatile T, + * otherwise T. 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 volatile * 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 + * false, this general * template catches the case that - * it is @p{true}, i.e. in a + * it is true, i.e. in a * sense it is also a * specialization since a - * @p{bool} can only have two + * bool 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 + * false, i.e. the * non-volatile case. */ template struct PossiblyVolatile @@ -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 subscribe to this object. The destructor the used + * object inherits from the Subscriptor 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}. + * *this. */ Subscriptor& operator = (const Subscriptor&); @@ -168,7 +168,7 @@ class Subscriptor /** * Exception: object should be used - * when @p{unsubscribe} is called. + * when unsubscribe 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 mutable 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 + * volatile. However, this is * counter-productive in non-MT * mode since it may pessimize * code. So use the above diff --git a/deal.II/base/include/base/table.h b/deal.II/base/include/base/table.h index 690303dd3c..9096721050 100644 --- a/deal.II/base/include/base/table.h +++ b/deal.II/base/include/base/table.h @@ -47,7 +47,7 @@ template class Table<6,T>; public: /** * Access the value of the - * @p{i}th index. + * ith index. */ unsigned int operator[] (const unsigned int i) const; @@ -65,8 +65,8 @@ template 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 N), which only differ in the way they + * implement their constructors (they take N 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 operator[]. 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 operator[], 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}. The template parameter @p{C} may be either true or + * Table. The template parameter C 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 N indices, the effect of applying operator[] is + * getting access to something we N-1 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 operator[] 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 P: it indicates, how many remaining indices + * there are. For a vector, P 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 operator[], an object with P=1 emerges. * - * The value of @p{P} is also used to determine the stride: this + * The value of P 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 operator[] 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 P. * * 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 Table 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 Table 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>}, or even higher + * constructs like std::vector>, 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 N 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 N 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 operator() 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 operator[] 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[]} + * std::vector objects, where we had to use the operator[] * 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 doubles), while the Table * 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 src * 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 src * into the array. The size is * adjusted if needed. * * This function requires that the - * type @p{T2} is convertible to - * @p{T}. + * type T2 is convertible to + * T. */ template TableBase& operator = (const TableBase &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}. + * n_elements()==0. */ 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 entries contains + * n_rows()*n_cols() * 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 + * T2, 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 reinit 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 (vector2d), 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 + * vector2d 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 (i,j). * * 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 vector2d. */ T & el (const unsigned int i, const unsigned int j); /** * Return the value of the - * element @p{(i,j)} as a + * element (i,j) 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 vector2d. */ const T & el (const unsigned int i, const unsigned int j) const; diff --git a/deal.II/base/include/base/template_constraints.h b/deal.II/base/include/base/template_constraints.h index 3b0298e706..8388d61956 100644 --- a/deal.II/base/include/base/template_constraints.h +++ b/deal.II/base/include/base/template_constraints.h @@ -22,7 +22,7 @@ template 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} + * true first template argument declares a local typedef type * 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. diff --git a/deal.II/base/include/base/tensor.h b/deal.II/base/include/base/tensor.h index b39b5ee528..7a1cee97bf 100644 --- a/deal.II/base/include/base/tensor.h +++ b/deal.II/base/include/base/tensor.h @@ -25,7 +25,7 @@ template 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 contract 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 dimension() * because now it is possible to * get the dimension at compile * time without the expansion and @@ -125,26 +125,26 @@ class Tensor Tensor & operator -= (const Tensor &); /** - * Scale the tensor by @p{factor}, i.e. multiply - * all coordinates by @p{factor}. + * Scale the tensor by factor, i.e. multiply + * all coordinates by factor. */ Tensor & operator *= (const double &factor); /** - * Scale the vector by @p{1/factor}. + * Scale the vector by 1/factor. */ Tensor & operator /= (const double &factor); /** * Add two tensors. If possible, use - * @p{operator +=} instead since this does not + * operator += instead since this does not * need to copy a point at least once. */ Tensor operator + (const Tensor &) const; /** * Subtract two tensors. If possible, use - * @p{operator +=} instead since this does not + * operator += instead since this does not * need to copy a point at least once. */ Tensor operator - (const Tensor &) const; @@ -431,7 +431,7 @@ std::ostream & operator << (std::ostream &out, const Tensor &p) /** * Contract a tensor of rank 1 with a tensor of rank 1. The result is - * @p{sum_j src1[j] src2[j]}. + * sum_j src1[j] src2[j]. * * @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]}. + * dest[i] = sum_j src1[i][j] src2[j]. * * @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]}. + * dest[i] = sum_j src1[j] src2[j][i]. * * @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]}. + * dest[i][k] = sum_j src1[i][j] src2[j][k]. * * @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 index1 of the first tensor, + * and index2 of the second tensor. Thus, if index1==2, + * index2==1, the result is the usual contraction, but if for + * example index1==1, index2==2, then the result is + * dest[i][k] = sum_j src1[j][i] src2[k][j]. * * 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 index1 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]}. + * dest[i][j][l] = sum_k src1[i][j][k] src2[k][l]. * * @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]}. + * dest[i][j][l] = sum_k src1[i][k] src2[k][j][l]. * * @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]}. + * dest[i][j][k][l] = sum_m src1[i][j][m] src2[m][k][l]. * * @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]}. + * dst[i][j] = src1[i] * src2[j]. * * @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]}. + * dst[i][j][k] = src1[i] * src2[j][k]. * * @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]}. + * dst[i][j][k] = src1[i][j] * src2[k]. * * @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 + * dst[i] = src1 * src2[i]. Of course, this is only a scaling of + * src2, 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 + * dst[i] = src1[i] * src2. Of course, this is only a scaling of + * src1, 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 dim==2 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 dim==3 case in the switch). * * @author Guido Kanschat, 2001 */ @@ -861,7 +861,7 @@ double determinant (const Tensor &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 rank // 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 dim==2. * * @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 dim==3. * * @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 dim==1,2,3. * * @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 dim==1. * * @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 dim==2. * * @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 dim==3. * * @author Wolfgang Bangerth, 2002 */ diff --git a/deal.II/base/include/base/tensor_base.h b/deal.II/base/include/base/tensor_base.h index 1e0429ff47..336848bf12 100644 --- a/deal.II/base/include/base/tensor_base.h +++ b/deal.II/base/include/base/tensor_base.h @@ -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 class Tensor<1,dim>; /** - * This class is a specialized version of the @p{Tensor} class. + * This class is a specialized version of the Tensor 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 Point class * which acts as a tensor of rank one but has more functionality. */ template @@ -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 dimension() * 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 dim==0 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 initialize==true; 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 indexth * coordinate. * * Note that the derived - * @p{Point} class also provides - * access through the @p{()} + * Point class also provides + * access through the () * operator for * backcompatibility. */ @@ -131,11 +131,11 @@ class Tensor<1,dim> /** * Read and write access to the - * @p{index}th coordinate. + * indexth coordinate. * * Note that the derived - * @p{Point} class also provides - * access through the @p{()} + * Point class also provides + * access through the () * 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}. + * factor, i.e. multiply all + * coordinates by factor. */ Tensor<1,dim> & operator *= (const double &factor); /** - * Scale the vector by @p{1/factor}. + * Scale the vector by 1/factor. */ 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 operator += 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 operator += * 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 dim==0 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 x1 x2 x3 etc. */ template 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 diff --git a/deal.II/base/include/base/tensor_function.h b/deal.II/base/include/base/tensor_function.h index d1fc171c5b..fa9c0bd32a 100644 --- a/deal.II/base/include/base/tensor_function.h +++ b/deal.II/base/include/base/tensor_function.h @@ -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 + * Function class, one can ask for a specific component only, or + * use the vector_value 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 Function 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 value * functions. */ typedef Tensor value_type; @@ -130,12 +130,12 @@ class TensorFunction : public FunctionTime, virtual value_type value (const Point &p) const; /** - * Set @p{values} to the point + * Set values to the point * values of the function at the - * @p{points}. It is assumed - * that @p{values} already has + * points. It is assumed + * that values already has * the right size, i.e. the same - * size as the @p{points} array. + * size as the points array. */ virtual void value_list (const std::vector > &points, std::vector &values) const; @@ -147,12 +147,12 @@ class TensorFunction : public FunctionTime, virtual gradient_type gradient (const Point &p) const; /** - * Set @p{gradients} to the + * Set gradients to the * gradients of the function at - * the @p{points}. It is assumed - * that @p{values} already has + * the points. It is assumed + * that values already has * the right size, i.e. the same - * size as the @p{points} array. + * size as the points array. */ virtual void gradient_list (const std::vector > &points, std::vector &gradients) const; diff --git a/deal.II/base/include/base/thread_management.h b/deal.II/base/include/base/thread_management.h index 858a0f7145..dd3c4b86f0 100644 --- a/deal.II/base/include/base/thread_management.h +++ b/deal.II/base/include/base/thread_management.h @@ -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 spawn 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}. + * acquire and release. */ 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 spawn 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 posix_cond_wait 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 count 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 count * 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}. + * acquire and release. */ class ScopedLock { @@ -355,7 +355,7 @@ namespace Threads * condition variables a * friend, since it needs * access to the - * @p{pthread_mutex_t} + * pthread_mutex_t * 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 posix_cond_wait 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. pthread_create for the * POSIX thread interface), or if * they are killed (e.g. either - * through @p{pthread_exit} from + * through pthread_exit from * the spawned thread, or - * @p{pthread_kill} from another + * pthread_kill 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 [begin,end) + * into n_intervals 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 n_intervals. The * type of the iterators has to * fulfill the requirements of a * forward iterator, - * i.e. @p{operator++} must be + * i.e. operator++ 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])}. + * [begin[i],end[i]). */ template std::vector > @@ -615,7 +615,7 @@ namespace Threads const unsigned int n_intervals); /** - * Split the interval @p{[begin,end)} + * Split the interval [begin,end) * 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 std::exception 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 std::exception, 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 + * join() member function * as already been called. If - * @p{true}, then @p{join} + * true, then join * 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 + * Thread<> 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 join() * 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 + * thread 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 void, * 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 spawn family of * functions. * * We would like to make this * constructor private and only * grant the - * @p{wrapper_base::fire_up} + * wrapper_base::fire_up * 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. + * spawn 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 join(). */ 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 entry_point, * 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 + * true. 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn 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 spawn * 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 spawn * 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 spawn 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn * 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 spawn 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 --------------------------- diff --git a/deal.II/base/include/base/timer.h b/deal.II/base/include/base/timer.h index 427b025ff9..d373e92e2e 100644 --- a/deal.II/base/include/base/timer.h +++ b/deal.II/base/include/base/timer.h @@ -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 start/stop 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 start * was called the last time or when the - * object was created and no @p{stop} was + * object was created and no stop was * issued in between. */ double start_time; /** - * Similar to @p{start_time}, but + * Similar to start_time, but * needed for children threads * in multithread mode. Value of - * the user time when @p{start} + * the user time when start * was called the last time or * when the object was created - * and no @p{stop} was issued in + * and no stop was issued in * between. * * For some reason (error in * operating system?) the * function call - * @p{getrusage(RUSAGE_CHILDREN,.)} + * getrusage(RUSAGE_CHILDREN,.) * gives always 0 (at least * on Solaris7). Hence the - * @p{Timer} class still does not + * Timer 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 + * start/stop cycles. The time for * the present cycle is not included. */ double cumulative_time; -- 2.39.5