void create_polynomial_ordering(std::vector<unsigned int> &index_map) const;
/**
- * Degree <tt>p<tt> of the
+ * Degree <tt>p</tt> of the
* polynomial space $P_p$,
- * i.e. the number <tt>p<tt>
+ * i.e. the number <tt>p</tt>
* which was given to the
* constructor.
*/
TriaIterator<dim,DoFObjectAccessor<celldim, dim> > child (const unsigned int) const;
/**
- * Distribute a local (cell based) vector
- * to a global one by mapping the local
- * numbering of the degrees of freedom to
- * the global one and entering the local
- * values into the global vector.
+ * Distribute a local (cell
+ * based) vector to a global one
+ * by mapping the local numbering
+ * of the degrees of freedom to
+ * the global one and entering
+ * the local values into the
+ * global vector.
*
- * The elements are @em{added} up to the
- * elements in the global vector, rather
- * than just set, since this is usually
- * what one wants.
+ * The elements are
+ * <em>added</em> up to the
+ * elements in the global vector,
+ * rather than just set, since
+ * this is usually what one
+ * wants.
*/
template <typename number, typename OutputVector>
void
* the global one and entering the local
* values into the global vector.
*
- * The elements are @em{added} up to the
- * elements in the global vector, rather
- * than just set, since this is usually
- * what one wants.
+ * The elements are
+ * <em>added</em> up to the
+ * elements in the global vector,
+ * rather than just set, since
+ * this is usually what one
+ * wants.
*/
template <typename number, typename OutputVector>
void
* the global one and entering the local
* values into the global vector.
*
- * The elements are @em{added} up to the
- * elements in the global vector, rather
- * than just set, since this is usually
- * what one wants.
+ * The elements are
+ * <em>added</em> up to the
+ * elements in the global vector,
+ * rather than just set, since
+ * this is usually what one
+ * wants.
*/
template <typename number, typename OutputVector>
void
TriaIterator<dim,DoFObjectAccessor<3, dim> > child (const unsigned int) const;
/**
- * Distribute a local (cell based) vector
- * to a global one by mapping the local
- * numbering of the degrees of freedom to
- * the global one and entering the local
- * values into the global vector.
+ * Distribute a local (cell
+ * based) vector to a global one
+ * by mapping the local numbering
+ * of the degrees of freedom to
+ * the global one and entering
+ * the local values into the
+ * global vector.
*
- * The elements are @em{added} up to the
- * elements in the global vector, rather
- * than just set, since this is usually
- * what one wants.
+ * The elements are
+ * <em>added</em> up to the
+ * elements in the global vector,
+ * rather than just set, since
+ * this is usually what one
+ * wants.
*/
template <typename number, typename OutputVector>
void
* two major drawbacks: keeping two matrices at the same time can be quite
* unacceptable in many cases, since these matrices may be several 10 or even
* 100 MB large. Secondly, the condensation process is quite expensive, since
- * @em{all} entries of the matrix have to be copied, not only those which are
- * subject to constraints.
+ * <em>all</em> entries of the matrix have to be copied, not only
+ * those which are subject to constraints.
*
* @item Use only one sparsity pattern and one matrix: doing it this way, the
* condense functions add nonzero entries to the sparsity pattern of the
* in the already condensed form.
*
*
- * @section3{Condensing vectors}
+ * @sect3{Condensing vectors}
*
* Condensing vectors works exactly as described above for matrices. Note that
* condensation is an idempotent operation, i.e. doing it more than once on a
* techniques as mentioned above to avoid their use.
*
*
- * @section3{Distributing constraints}
+ * @sect3{Distributing constraints}
*
* After solving the condensed system of equations, the solution vector has to
* be redistributed. This is done by the two @p{distribute} function, one
* degrees of freedom. This renumbering may only exchange whole blocks
* and must not destroy the block structure.
*
- * Given an ordered vector of cells, the function @p{cell_wise_dg}
+ * Given an ordered vector of cells, the function cell_wise_dg()
* accomplishes this. Inside the cells, the previous ordering will be
- * preserved, so it may be useful to apply @component_wise} first.
+ * preserved, so it may be useful to apply component_wise() first.
*
*
* @sect2{Random renumbering}
* shape functions cannot be
* associated with a single
* vector component. In this
- * case, if @em{one} shape vector
- * component of this element is
- * flagged in
+ * case, if <em>one</em> shape
+ * vector component of this
+ * element is flagged in
* @p{component_select}, then
* this is equivalent to
- * selecting @em{all} vector
+ * selecting <em>all</em> vector
* components corresponding to
* this non-primitive base
* element.
// $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
* @p{FE_Q<2>}, you can omit the
* dimension argument altogether,
* or replace it with the string
- * @p{<dim>}. The reason is that
- * the dimension argument may be
- * cumbersome if the name of a
- * finite element is given in an
- * input file that may be used to
- * control operation of the
- * program in different space
+ * <tt>@<dim@></tt>. The reason
+ * is that the dimension argument
+ * may be cumbersome if the name
+ * of a finite element is given
+ * in an input file that may be
+ * used to control operation of
+ * the program in different space
* dimensions. Running the
* program in another space
* dimension would then require
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003 by the deal.II authors
+// Copyright (C) 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
/**
* This class provides a certain view on a range of triangulation or
* DoFHandler iterators by only iterating over elements that satisfy a
- * given filter (called a @em{predicate}, following the notation of
- * the C++ standard library). Once initialized with a predicate and a
- * value for the iterator, a filtered iterator hops to the next or
+ * given filter (called a <em>predicate</em>, following the notation
+ * of the C++ standard library). Once initialized with a predicate and
+ * a value for the iterator, a filtered iterator hops to the next or
* previous element that satisfies the predicate if operators ++ or --
* are invoked. Intermediate iterator values that lie in between but
* do not satisfy the predicate are skipped. It is thus very simple to
* iterators a nightmare, we rather give the predicate as an
* unchangeable entity to the constructor. Note that one can assign a
* filtered iterator with one predicate to another filtered iterator
- * with another type; yet, this does @em{not} change the predicate of
- * the assigned-to iterator, only the pointer indicating the iterator
- * is changed.
+ * with another type; yet, this does <em>not</em> change the predicate
+ * of the assigned-to iterator, only the pointer indicating the
+ * iterator is changed.
*
* If a filtered iterator is not assigned a value of the underlying
* (unfiltered) iterator type, the default value is taken. If,
// $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
* domain which is the tensor product of an interval $[a,b]$ in
* the given number of spatial dimensions. If you want to create such
* a domain, which is a common test case for model problems, call
- * @ref{GridGenerator}@p{::hyper_cube (tria, a,b)}, which produces a
- * hypercube domain triangulated with exactly one element. You can
- * get tensor product meshes by successive refinement of this cell.
+ * GridGenerator::hyper_cube(tria, a,b), which produces a
+ * hypercube domain triangulated with exactly one element. You
+ * can get tensor product meshes by successive refinement of
+ * this cell.
*
* If you want the hypercube subdivided a certain number of
* times (and if this is not achievable by hierarchic
*
* @item Rectangular coordinate-parallel domains as a generalization
* of hypercubes are generated by
- * @ref{GridGenerator}@p{::hyper_rectangle (tria, p1, p2)}, with two
+ * GridGenerator::hyper_rectangle (tria, p1, p2), with two
* opposite corner points @p{p1} and @p{p2}.
*
* @item Rectangular coordinate-parallel domains with different numbers of
* cells in each coordinate direction are generated by
- * @ref{GridGenerator}@p{::subdivided_hyper_rectangle
- * (tria, int[dim] repetitions, p1, p2, colorize)}, with two
+ * GridGenerator::subdivided_hyper_rectangle
+ * (tria, int[dim] repetitions, p1, p2, colorize), with two
* opposite corner points @p{p1} and @p{p2}.
*
* @item Generalized L-shape domain:
- * using the @ref{GridGenerator}@p{::hyper_L (tria, a,b)} function produces
+ * using the GridGenerator::hyper_L (tria, a,b) function produces
* the hypercube with the interval $[a,b]$ without the hypercube
* made out of the interval $[(a+b)/2,b]$. Let, for example, be $a=-1$
* and $b=1$, then the hpyer-L in two dimensions is the region
* an error. The function is also implemented for three space dimensions.
*
* @item Hyper ball:
- * You get the circle or ball (or generalized: hyperball) around origin
- * @p{p} and with radius @p{r} by calling
- * @ref{GridGenerator}@p{::hyper_ball (tria, p, r)}. The circle is triangulated
- * by five cells, the ball by seven cells. The diameter of the center cell is
- * chosen so that the aspect ratio of the boundary cells after one refinement
- * is minimized in some way. To create a hyperball in one dimension results in
- * an error.
+ * You get the circle or ball (or generalized: hyperball) around
+ * origin @p{p} and with radius @p{r} by calling
+ * GridGenerator::hyper_ball (tria, p, r). The circle is
+ * triangulated by five cells, the ball by seven cells. The
+ * diameter of the center cell is chosen so that the aspect ratio
+ * of the boundary cells after one refinement is minimized in
+ * some way. To create a hyperball in one dimension results in an
+ * error.
*
* Do not forget to also attach a suitable boundary approximation object
* to the triangulation object you passed to this function if you later want
* @item Half Hyper ball:
* You get half of the circle generated by Hyper ball.
* with center @p{p} and with radius @p{r} by calling
- * @ref{GridGenerator}@p{::half_hyper_ball (tria, p, r)}. The half-circle is
+ * GridGenerator::half_hyper_ball (tria, p, r). The half-circle is
* triangulated by four cells. The diameter of the center cell is
* chosen to be the same as for the Hyper ball class.
* To create a half-hyperball in one dimension results in
* Do not forget to also attach a suitable boundary approximation object
* to the triangulation object you passed to this function if you later want
* the triangulation to be refined at the outer boundaries. The class
- * @ref{HalfHyperBallBoundary} will provide a boundary object.
+ * HalfHyperBallBoundary will provide a boundary object.
*
* @item Hyper shell: A hyper shell is the region between two hyper
* sphere with the same origin. Therefore, it is a ring in two
* spatial dimensions. To triangulation it, call the function
- * @ref{GridGenerator}@p{::hyper_shell (tria, origin, inner_radius, outer_radius, N)},
+ * GridGenerator::hyper_shell (tria, origin, inner_radius, outer_radius, N),
* where the center of the spheres as well as
* the inner and outer radius of the two spheres are given as
* shown.
* Usage of these iterators works mostly like with the STL iterators. Some
* examples taken from the @ref{Triangulation} source code follow.
* @begin{itemize}
- * @item @em{Counting the number of cells on a specific level}
+ * @item <em>Counting the number of cells on a specific level</em>
* @begin{verbatim}
* template <int dim>
* int Triangulation<dim>::n_cells (const int level) const {
* };
* @end{verbatim}
*
- * @item @em{Refining all cells of a triangulation}
+ * @item <em>Refining all cells of a triangulation</em>
* @begin{verbatim}
* template <int dim>
* void Triangulation<dim>::refine_global () {
* and read the flags of all used lines, quads, etc, not only of the
* active ones (well, activity is a concept which really only applies to
* cells, not for example to lines in 2D, so the abovementioned generalization
- * to @em{all} lines, quads, etc seems plausible).
+ * to <em>all</em> lines, quads, etc seems plausible).
*
* If you want to store more specific user flags, you can use the functions
* @p{save_user_flags_line} and @p{load_user_flags_line} and the generalizations
* at the old grid and the refinement flags for each cell.
*
* @begin{itemize}
- * @item @em{Regularization:} The algorithm walks over all cells checking
+ * @item <em>Regularization:</em> The algorithm walks over all cells checking
* whether the present cell is flagged for refinement and a neighbor of the
* present cell is refined once less than the present one. If so, flag the
* neighbor for refinement. Because of the induction above, there may be no
* on lower levels, but if these induce more refinement needed, this is
* performed later on when we visit them in out backward running loop.
*
- * @item @em{Smoothing:}
+ * @item <em>Smoothing:</em>
* @begin{itemize}
* @item @p{limit_level_difference_at_vertices}:
* First a list is set up which stores for each vertex
* *-------* *-------*
* @end{verbatim}
*
- * The @em{standard} direction of the faces is determined by the
+ * The <em>standard</em> direction of the faces is determined by the
* numbers the lines have within a given face. This is like follows:
* @begin{itemize}
* @item Faces 0 and 1:
* all faces that are consistent with this convention.
*
* For this reason, above convention is only what we call the
- * @em{standard orientation}. deal.II actually allows faces in 3d to
- * have either the standard direction, or its opposite, in which
- * case the lines that make up a cell would have reverted orders,
- * and the above line equivalences would not hold any more. You can
- * ask a cell whether a given face has standard orientation by
- * calling @p{cell->face_orientation(face_no)}: if the result is
- * @p{true}, then the face has standard orientation, otherwise its
- * normal vector is pointing the other direction. There are not very
- * many places in application programs where you need this
- * information actually, but a few places in the library make use of
- * this.
+ * <em>standard orientation</em>. deal.II actually allows faces in
+ * 3d to have either the standard direction, or its opposite, in
+ * which case the lines that make up a cell would have reverted
+ * orders, and the above line equivalences would not hold any
+ * more. You can ask a cell whether a given face has standard
+ * orientation by calling @p{cell->face_orientation(face_no)}: if
+ * the result is @p{true}, then the face has standard orientation,
+ * otherwise its normal vector is pointing the other
+ * direction. There are not very many places in application programs
+ * where you need this information actually, but a few places in the
+ * library make use of this.
*
* @sect4{Children}
*
private:
/**
- * Copy operator. This is
- * normally used in a context
- * like @p{iterator a,b;
- * *a=*b;}. Since the meaning is
- * to copy the object pointed to
- * by @p{b} to the object
- * pointed to by @p{a} and since
- * accessors are not real but
- * virtual objects, this
- * operation is not useful for
- * iterators on
- * triangulations. We declare
- * this function here private,
- * thus it may not be used from
- * outside. Furthermore it is
- * not implemented and will give
- * a linker error if used
- * anyway.
+ * Copy operator. This is
+ * normally used in a context
+ * like <tt>iterator a,b;
+ * *a=*b;</tt>. Since the meaning
+ * is to copy the object pointed
+ * to by @p{b} to the object
+ * pointed to by @p{a} and since
+ * accessors are not real but
+ * virtual objects, this
+ * operation is not useful for
+ * iterators on
+ * triangulations. We declare
+ * this function here private,
+ * thus it may not be used from
+ * outside. Furthermore it is
+ * not implemented and will give
+ * a linker error if used anyway.
*/
void operator = (const TriaObjectAccessor<2, dim> &);
*
* The following refers to any space dimension:
*
- * This class allows access to a @em{cell}, which is a line in 1D and
- * a quad in 2D. Cells have more functionality than lines or quads by
- * themselves, for example they can be flagged for refinement, they
+ * This class allows access to a <tt>cell</tt>, which is a line in 1D
+ * and a quad in 2D. Cells have more functionality than lines or quads
+ * by themselves, for example they can be flagged for refinement, they
* have neighbors, they have the possibility to check whether they are
* at the boundary etc. This class offers access to all this data.
*
/**
* Copy operator. This is
* normally used in a context
- * like @p{iterator a,b;
- * *a=*b;}. Since the meaning is
+ * like <tt>iterator a,b;
+ * *a=*b;</tt>. Since the meaning is
* to copy the object pointed to
* by @p{b} to the object
* pointed to by @p{a} and since
/**
- * This specialization of @ref{TriaRawIterator} provides access only to the
- * @em{used} lines, quads, cells, etc.
+ * This specialization of TriaRawIterator provides access only to
+ * the <em>used</em> lines, quads, cells, etc.
*/
template <int dim, typename Accessor>
class TriaIterator : public TriaRawIterator<dim,Accessor>
/**
- * This specialization of @ref{TriaIterator} provides access only to the
- * @em{active} lines, quads, cells, etc. An active cell is a cell which is not
- * refined and thus a cell on which calculations on the finest level are done.
+ * This specialization of TriaIterator provides access only to the
+ * <em>active</em> lines, quads, cells, etc. An active cell is a
+ * cell which is not refined and thus a cell on which calculations
+ * on the finest level are done.
*/
template <int dim, typename Accessor>
class TriaActiveIterator : public TriaIterator<dim,Accessor>
* at the boundary), @p{level=index=-1}
* is set.
*
- * @em{Conventions:} The @p{i}th neighbor
- * of a cell is the one which shares
- * the @p{i}th face (@p{Line} in 2D, @p{Quad}
- * in 3D) of this cell.
+ * <em>Conventions:</em> The
+ * @p{i}th neighbor of a cell is
+ * the one which shares the
+ * @p{i}th face (@p{Line} in 2D,
+ * @p{Quad} in 3D) of this cell.
*
* The neighbor of a cell has at most the
* same level as this cell, i.e. it may
// $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
/**
* Grant access to the multilevel degrees of freedom located on quads.
*
- * @ref DoFLineAccessor
+ * DoFLineAccessor
*/
template <int dim>
class MGDoFObjectAccessor<2, dim> : public MGDoFAccessor<dim>,
/**
* Grant access to the multilevel degrees of freedom located on hexhedra.
*
- * @ref DoFLineAccessor
+ * DoFLineAccessor
*/
template <int dim>
class MGDoFObjectAccessor<3, dim> : public MGDoFAccessor<dim>,
* for some @p{Object} classes,
* most notably for vectors and
* matrices. Note that if
- * @p{Object==Vector<T>}, @p{clear}
- * will set all entries to zero,
- * while if
- * @p{Object==vector<T>},
- * @p{clear} deletes the elements
+ * <tt>Object==Vector@<T@></tt>,
+ * clear() will set all entries
+ * to zero, while if
+ * <tt>Object==vector@<T@></tt>,
+ * clear() deletes the elements
* of the vectors. This class
* might therefore not be useful
* for STL vectors.
// $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
* intervals as well; the number of these intervals must be given to
* the @p{build_patches} function. It is noted, however, that while
* this function generates nice pictures of the whole domain, it often
- * produces @em{very} large output files.
+ * produces <em>very</em> large output files.
*
*
* @sect3{Interface}
/**
* Calls the @p{interpolate}
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim, class InputVector>
static void
/**
* Calls the @p{interpolate}
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim, class InputVector>
static void
/**
* Calls the @p{estimate}
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <typename InputVector>
static void estimate (const DoFHandler<dim> &dof,
/**
* Calls the @p{estimate}
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <typename InputVector>
static void estimate (const DoFHandler<dim> &dof,
// $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
*
* There exist two versions of each function. One with a @ref{Mapping}
* argument and one without. If a code uses a mapping different from
- * @ref{MappingQ1} the functions @em{with} mapping argument should be
- * used. Code that uses only @ref{MappingQ1} may also use the
- * functions @em{without} @ref{Mapping} argument. Each of these latter
- * functions create a @ref{MappingQ1} object and just call the
+ * @ref{MappingQ1} the functions <em>with</em> mapping argument should
+ * be used. Code that uses only @ref{MappingQ1} may also use the
+ * functions <em>without</em> @ref{Mapping} argument. Each of these
+ * latter functions create a @ref{MappingQ1} object and just call the
* respective functions with that object as mapping argument. The
* functions without @ref{Mapping} argument still exist to ensure
* backward compatibility. Nevertheless it is advised to change the
const Function<dim> * const a = 0);
/**
- * Calls the @p{create_mass_matrix}
+ * Calls the create_mass_matrix()
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim, typename number>
static void create_mass_matrix (const DoFHandler<dim> &dof,
const Function<dim> * const a = 0);
/**
- * Calls the @p{create_mass_matrix}
+ * Calls the create_mass_matrix()
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim, typename number>
static void create_mass_matrix (const DoFHandler<dim> &dof,
/**
* Calls the
- * @p{create_boundary_mass_matrix}
+ * create_boundary_mass_matrix()
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static
const Function<dim> * const a = 0);
/**
- * Calls the @p{create_laplace_matrix}
+ * Calls the
+ * create_laplace_matrix()
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void create_laplace_matrix (const DoFHandler<dim> &dof,
const Function<dim> * const a = 0);
/**
- * Calls the @p{create_laplace_matrix}
+ * Calls the
+ * create_laplace_matrix()
* function, see above, with
- * @p{mapping=MappingQ1<dim>()}.
+ * <tt>mapping=MappingQ1@<dim@>()</tt>.
*/
template <int dim>
static void create_laplace_matrix (const DoFHandler<dim> &dof,
// $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
* To see how this function work, note that
* the function @p{solve_primal_problem} only
* consists of a call to
- * @p{do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
+ * <tt>do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
* mem_fun(&TimeStepBase::solve_primal_problem),
- * timestepping_data_primal, forward);}.
+ * timestepping_data_primal, forward);</tt>.
*
* Note also, that the given class from which
* the two functions are taken needs not
* one line per row of the format
* <tt>[i,j1,j2,j3,...]</tt>. <i>i</i>
* is the row number and
- * <i>jn</n> are the allocated
+ * <i>jn</i> are the allocated
* columns in this row.
*/
void print (std::ostream &out) const;
* one line per row of the format
* <tt>[i,j1,j2,j3,...]</tt>. <i>i</i>
* is the row number and
- * <i>jn</n> are the allocated
+ * <i>jn</i> are the allocated
* columns in this row.
*/
void print (std::ostream &out) const;
* @p{n} and initialize all
* elements with zero.
*
- * The constructor is made explicit to
- * avoid accidents like this:
- * @p{v=0;}. Presumably, the user wants
- * to set every element of the vector to
- * zero, but instead, what happens is
- * this call: @p{v=Vector<number>(0);},
- * i.e. the vector is replaced by one of
- * length zero.
+ * The constructor is made
+ * explicit to avoid accidents
+ * like this:
+ * @p{v=0;}. Presumably, the user
+ * wants to set every element of
+ * the vector to zero, but
+ * instead, what happens is this
+ * call:
+ * <tt>v=Vector@<number@>(0);</tt>,
+ * i.e. the vector is replaced by
+ * one of length zero.
*/
explicit Vector (const unsigned int n);