<p>deal.II has an extensive reference documentation generated
by <a href="http://www.doxygen.org">Doxygen</a>. One of the many
- features of Doxygen is, that all class names, function noames and so
+ features of Doxygen is, that all class names, function names and so
on are cross-linked in the documentation, and a single click
suffices to jump to the documentation of an object.</p>
* can solve now, there is no reason for the number of non-zero entries in a
* sparse matrix to go over four billions. Thus, we still use unsigned int
* for, e.g., row_lengths in the object.
+ * </dd>
*
- *
+ * </dl>
*/
* to adding elements or setting them. In some cases, not all processors may
* be adding elements, for example if a processor does not own any cells when
* using a very coarse (initial) mesh. For this reason, compress() takes an
- * argument of type VectorOperation, which can be either ::add, or ::insert.
+ * argument of type VectorOperation, which can be either ::%add, or ::%insert.
* This argument is required for vectors and matrices starting with the 7.3
* release.
*
*
* @subsection Inst2p Provided instances
*
- * Like with the classes in section Inst1, the instances provided in the
+ * Like with the classes in section @ref Inst1, the instances provided in the
* library are often listed in the documentation of that class in a form
* similar to this:
@verbatim
\right)_\Omega,
@f}
* where $\varepsilon(\mathbf u) = \frac 12 \left([\nabla\mathbf u] +
- * [\nabla\mathbf u]^2\right)$ is the symmetrized gradient.
+ * [\nabla\mathbf u]^T\right)$ is the symmetrized gradient.
* In the second to last step, we used that the scalar product between
* an arbitrary tensor $\nabla\mathbf u$ and a symmetric tensor
* $\frac 12[\partial_i v_j + \partial_j v_i]$ equals the scalar product
<li> New: Restructured the internals of <code>PETScWrappers::Precondition*</code>
to allow a PETSc PC object to exist without a solver. New: Use
-<code>Precondition*::vmult()</code> to apply the preconditioner once.
+<code>Precondition*::%vmult()</code> to apply the preconditioner once.
Preconditioners now have a default constructor and an <code>initialize()</code>
function and are no longer initialized in the solver call,
but in the constructor or <code>initialize()</code>.
<br>
(Timo Heister, 2013/02/19)
-<li> New: PETScWrappers::*Matrix::add(other, factor) to
+<li> New: PETScWrappers::*Matrix::%add(other, factor) to
add a scaled other matrix to the current matrix.
<br>
(Jose Javier Munoz Criollo, 2013/02/19)
@endcode
From hereon, we can refer to the type <code>typename
-InnerPreconditioner@<dim@>::type</code> and automatically get the correct
+InnerPreconditioner@<dim@>::%type</code> and automatically get the correct
preconditioner class. Because of the similarity of the interfaces of the two
classes, we will be able to use them interchangeably using the same syntax in
all places.
this case of VisIt) to show vector data; this is the result of us
declaring the velocity components of the finite element in use to be a
set of vector components, rather than independent scalar components in
-the <code>StokesProblem@<dim@>::output_results</code> function of this
+the <code>StokesProblem@<dim@>::%output_results</code> function of this
tutorial program.
* same. The handling in SmartPointer will take care of this.
*
* @note Due to a problem with <tt>volatile</tt> declarations, this
- * additional feature is switched of if multithreading is used.
+ * additional feature is switched off if multithreading is used.
*
* @ingroup memory
* @author Guido Kanschat, 1998 - 2005
* template <>
* void X<dim>::f<0> () { ...operate on the vertices of a cell... }
*
- * template <int dim, int subdim> void f(X<dim> &x) {
+ * template <int dim, int subdim> void g(X<dim> &x) {
* x.f<subdim> ();
* }
* @endcode
* template <int dim>
* void X<dim>::f (int2type<1>) { ...operate on the lines of a cell... }
*
- * template <int dim, int subdim> void f(X<dim> &x) {
+ * template <int dim, int subdim> void g(X<dim> &x) {
* x.f (int2type<subdim>());
* }
* @endcode
* templates.
*
* Use this class as in
- * <code>fixed_int_power@<5,2@>::value</code>
+ * <code>fixed_int_power@<5,2@>::%value</code>
* to compute 5<sup>2</sup>.
*/
template <int a, int N>
* the transform() functions of
* inheriting classes in order to
* work.
+ *
+ * @ingroup mapping
*/
enum MappingType
{
EPS *get_eps ();
/**
- * Solve the linear system for </code>n_eigenpairs</code>
+ * Solve the linear system for <code>n_eigenpairs</code>
* eigenstates. Parameter <code>n_converged</code> contains the
* actual number of eigenstates that have . converged; this can
* be both fewer or more than n_eigenpairs, depending on the
/**
* Write the data of this object en bloc to a file. This is done in a binary
* mode, so the output is neither readable by humans nor (probably) by other
- * computers using a different operating system of number format.
+ * computers using a different operating system or number format.
*
* The purpose of this function is that you can swap out matrices and
* sparsity pattern if you are short of memory, want to communicate between
projects / dealii-svn.git / commitdiff