/**
- * A class that simplifies the process of execution logging by
+ * A class that simplifies the process of execution logging. It does so by
* providing
* \begin{itemize}
* \item a push and pop mechanism for prefixes, and
/**
* Kludge to make one of the egcs snapshots
- * happy, since it produces an internal
+ * happy. Necessary since it produces an internal
* compiler error when accessing #s.std#.
* Remove this function at the first
* possible time.
* are no changed entry values in a
* subsection; therefore #enter_subsection#
* has to create the tree in both #Defaults#
- * and #changed_entries.
+ * and #changed_entries#.
*/
Section changed_entries;
* of the two solvers.
*
* Opposite to a variant entry, an array entry looks like this:
- * \begin{verabtim}
+ * \begin{verbatim}
* set Output file = ofile.{{ 1 | 2 | 3 | 4 }}
* \end{verbatim}
* This indicates that if there are variant entries producing a total of four
* Construct an object with given subsection
* path, name and value. The splitting up
* into the different variants is done
- * later by #split_different_values.
+ * later by #split_different_values#.
*/
Entry (const vector<string> &Path, const string &Name, const string &Value);
* consumption for those iterative solution methods using a larger number of
* auxiliary vectors (e.g. methods using explicite orthogonalization
* procedures).
- * \end{verbatim}
+ * \end{itemize}
*
* Usually, the second way is chosen since memory consumption upon construction
* of a second matrix rules out the first possibility.
* with embedded spaces, the basis function
* phi0[i] on the coarse grid can be
* expressed by
- * \sum_c \sum_j p^c_{ji) phi1[j]
+ * $\sum_c \sum_j p^c_{ji} phi1[j]$
* where the sum over c runs over the child
- * cells and phi1[j] is the j_th basis
- * function on the c_th child cell. Note
+ * cells and phi1[j] is the jth basis
+ * function on the cth child cell. Note
* that we need here the transpose of the
- * matrix p^c (p^c is returned by this
+ * matrix $p^c$ ($p^c$ is returned by this
* function with parameter c).
*
* Upon assembling the transfer matrix
* of the bounding lines of the quadrilateral,
* $n=5d_v..5d_v+4*d_l-1$ are for the degrees of freedom on
* the four lines connecting the center vertex to the outer boundary of the
- * mother face, n=5d_v+4*d_l...5d_v+4*d_l+8*d_l-1# for the degrees of freedom
+ * mother face, $n=5d_v+4*d_l...5d_v+4*d_l+8*d_l-1$ for the degrees of freedom
* on the small lines surrounding the quad,
* and $n=5d_v+12*d_l...5d_v+12*d_l+4*d_q-1$ for the dofs on the
* four child faces. Note the direction of the lines at the boundary of the
* The derivatives of the Jacobi matrices at the quadrature points with respect
* to unit cell coordinates is stored in the field names
* #jacobi_matrices_grad#. Since the gradient of a shape function is given by
- * $\partial_i \phi = \sum_k \hat\partial_k \hat\phi J_{ki}$, where $\hat$
- * denotes differentiation on the unit cell, the second derivative of a
- * function is given by
+ * $\partial_i \phi = \sum_k \hat\partial_k \hat\phi J_{ki}$, where
+ * $\hat\partial$ denotes differentiation on the unit cell, the second
+ * derivative of a function is given by
* $\partial_j \partial i \phi
* =
* \hat\partial_l [ (\hat \partial_k \hat\phi) J_{ki} ] J_{lj}
* boundary approximation object if you want the triangulation to be refined
* at the outer boundaries.
*
- * \item Reading in a triangulation: By using an object of the \Ref{#DataIn#}
+ * \item Reading in a triangulation: By using an object of the #DataIn#
* class, you can read in fairly general triangulations. See there for
* more information. The mentioned class uses the interface described
* directly below to transfer the data into the triangulation.
void set (const Quad &q) const;
/**
- * Return index of vertex #i=0,1,2,3# of
+ * Return index of vertex #i=0 through 3# of
* a quad. The #i#th vertex is the common
* one of line #i# and #(i+3)%4#. See also
* the introduced convention
void set (const Hexahedron &h) const;
/**
- * Return index of vertex #i=0,...,7# of
+ * Return index of vertex #i=0 through 7# of
* a hex. The convention regarding the
* numbering of vertices is laid down
* in the documentation of the
IteratorState state () const;
/**
- * Print the iterator in the form
- * #level.index# to #out#.
+ * Print the iterator to #out#. The
+ * format is like #level.index#.
*/
void print (ostream &out) const;
template <int dim, typename Accessor>
inline
-IteratorState TriaRawIterator<dim,Accessor>::state () const {
+IteratorState
+TriaRawIterator<dim,Accessor>::state () const {
return accessor.state ();
};
+// sorry that the declaration of this function looks so ragged; I had
+// to do it this way since otherwise doc++ could not parse it correctly.
template <int dim, typename Accessor>
inline
-bool TriaRawIterator<dim,Accessor>::operator < (const TriaRawIterator &i) const {
+bool
+TriaRawIterator<dim,Accessor>::
+operator < (const TriaRawIterator &i) const {
Assert (state() != invalid, ExcDereferenceInvalidObject());
Assert (i.state() != invalid, ExcDereferenceInvalidObject());
template <int dim, typename Accessor>
inline
-void TriaRawIterator<dim,Accessor>::print (ostream &out) const {
+void
+TriaRawIterator<dim,Accessor>::print (ostream &out) const {
out << accessor.level() << "." << accessor.index();
};
* The three states an iterator can be in: valid, past-the-end and
* invalid.
*/
-enum IteratorState { valid, past_the_end, invalid };
+enum IteratorState {
+ valid,
+ past_the_end,
+ invalid
+};
*
* To actually apply the boundary conditions, use is made of the
* #MatrixTools::apply_boundary_values# function and by interpolation of
- * the boundary_values using the #MatrixTool::interpolate_boundary_values#
+ * the #boundary_values# using the #MatrixTool::interpolate_boundary_values#
* function. See there for more information.
*
*
* refinement, to the function #out#
* which then is a vector on the refined grid.
* It assumes the vectors having the
- * right sizes (i.e. in.size()==n_dofs_old,
- * out.size()==n_dofs_refined)
+ * right sizes (i.e. #in.size()==n_dofs_old#,
+ * #out.size()==n_dofs_refined#)
*
* Calling this function is allowed only
* if #prepare_for_pure_refinement# is called
* will be refined) or the
* #vector<double> dof_values# (if the
* children of this cell will be deleted)
- * is needed, hence one user_pointer should
+ * is needed, hence one #user_pointer# should
* be sufficient, but to allow some errorchecks
* and to preserve the user from making
* user errors the #user_pointer# will be
* The $H_1$ seminorm is the $L_2$ norm of the gradient of the difference. The
* full $H_1$ norm is the sum of the seminorm and the $L_2$ norm.
*
- * To get the {\it global} L_1 error, you have to sum up the entries in
+ * To get the {\it global} $L_1$ error, you have to sum up the entries in
* #difference#, e.g. using #Vector<double>::l1_norm# function.
- * For the global L_2 difference, you have to sum up the squares of the
+ * For the global $L_2$ difference, you have to sum up the squares of the
* entries and take the root of the sum, e.g. using #Vector<double>::l2_norm#.
* These two operations represent the
- * l_1 and l_2 norms of the vectors, but you need not take the absolute
+ * $l_1$ and $l_2$ norms of the vectors, but you need not take the absolute
* value of each entry, since the cellwise norms are already positive.
*
* To get the global mean difference, simply sum up the elements as above.
- * To get the L_\infty norm, take the maximum of the vector elements, e.g.
+ * To get the $L_\infty$ norm, take the maximum of the vector elements, e.g.
* using the #Vector<double>::linfty_norm# function.
*
* For the global $H_1$ norm and seminorm, the same rule applies as for the
/**
* Set the right block size before calling
* #precondition_BlockSOR#.
- * If block_size==1 BlockSOR is the
+ * If #block_size==1# BlockSOR is the
* same as SOR.
*/
void set_block_size (const unsigned int bsize);
/**
* Matrix-matrix-multiplication using
* transpose of #this#.
- * $C=A^T*B.
+ * $C=A^T*B$.
*/
template<typename number2>
void Tmmult (FullMatrix<number2>& C, const FullMatrix<number2>& B) const;
/**
* Return the norm of the vector #v# with
* respect to the norm induced by this
- * matrix, i.e. $\left<v,Mv\right>$. This
+ * matrix, i.e. $\left(v,Mv\right)$. This
* is useful, e.g. in the finite element
* context, where the $L_2$ norm of a
* function equals the matrix norm with
/**
* Matrix-vector multiplication: let
- * #dst = M*src# with #M# being this matrix.
+ * $dst = M*src$ with $M$ being this matrix.
*/
template <typename somenumber>
void vmult (Vector<somenumber>& dst, const Vector<somenumber>& src) const;
/**
* Matrix-vector multiplication: let
- * #dst = M^T*src# with #M# being this
+ * $dst = M^T*src$ with $M$ being this
* matrix. This function does the same as
* #vmult# but takes the transposed matrix.
*/
void backward_forward (Vector<somenumber>& v);
/**
- * Return the norm of the vector #v# with
+ * Return the norm of the vector $v$ with
* respect to the norm induced by this
- * matrix, i.e. $\left<v,Mv\right>$. This
+ * matrix, i.e. $\left(v,Mv\right)$. This
* is useful, e.g. in the finite element
* context, where the $L_2$ norm of a
* function equals the matrix norm with
/**
* Declare iterator types just like those
* for the C++ standard library:
- *
* Data type stored by this container.
*/
typedef Number value_type;
*/
//@{
/**
+ * Addition operator.
* Fast equivalent to #U.add(1, V)#.
*/
Vector<Number> & operator += (const Vector<Number> &V);
/**
+ * Subtraction operator.
* Fast equivalent to #U.add(-1, V)#.
*/
Vector<Number> & operator -= (const Vector<Number> &V);
/**
- * U(0-DIM)+=s.
+ * $U(0-DIM)+=s$.
* Addition of #s# to all components. Note
* that #s# is a scalar and not a vector.
*/