* consequently not be represented by either of these classes. Use an
* array of size 3 in this case, or the <code>std_cxx11::array</code>
* class. Alternatively, as in the case of vector-valued functions,
- * you can use objects of type Vector or <code>std::vector<code>.
+ * you can use objects of type Vector or <code>std::vector</code>.
*
*
* @tparam dim An integer that denotes the dimension of the space in which
/**
- * Global operator scaling a point vector by a scalar. @relates Point
+ * Global operator scaling a point vector by a scalar.
+ * @relates Point
*/
template <int dim, typename Number>
inline
/**
- * Global operator scaling a point vector by a scalar. @relates Point
+ * Global operator scaling a point vector by a scalar.
+ * @relates Point
*/
template <int dim>
inline
/**
* Output operator for points. Print the elements consecutively, with a space
- * in between. @relates Point
+ * in between.
+ * @relates Point
*/
template <int dim, typename Number>
inline
/**
* Output operator for points. Print the elements consecutively, with a space
- * in between. @relates Point
+ * in between.
+ * @relates Point
*/
template <int dim, typename Number>
inline
*
* @note This class does not support anisotropic refinement, because it
* relies on the p4est library that does not support this. Attempts to
- * refine cells anisotropically will result in errors. @note There is
+ * refine cells anisotropically will result in errors.
+ *
+ * @note There is
* currently no support for distributing 1d triangulations.
*
*
* @param[in] fe The finite element that will be used to represent
* the components of this composed element.
* @param[in] n_elements An integer denoting how many copies of
- * @fe this element should consist of.
+ * @p fe this element should consist of.
*/
FESystem (const FiniteElement<dim,spacedim> &fe,
const unsigned int n_elements);
* @dontinclude block_matrix_array.cc
*
* Obviously, we have to include the header file containing the definition of
- * BlockMatrixArray: @skipline block_matrix_array.h
+ * BlockMatrixArray:
+ * @skipline block_matrix_array.h
*
- * First, we set up some matrices to be entered into the blocks. @skip main
+ * First, we set up some matrices to be entered into the blocks.
+ * @skip main
* @until C.fill
*
* The BlockMatrixArray needs a VectorMemory<Vector<number> >
*
* @line Growing
*
- * Now, we are ready to build a <i>2x2</i> BlockMatrixArray. @line Block
+ * Now, we are ready to build a <i>2x2</i> BlockMatrixArray.
+ * @line Block
* First, we enter the matrix <tt>A</tt> multiplied by 2 in the upper left
- * block @line enter Now -1 times <tt>B1</tt> in the upper right block. @line
- * enter We add the transpose of <tt>B2</tt> to the upper right block and
+ * block
+ * @line enter
+ * Now -1 times <tt>B1</tt> in the upper right block.
+ * @line enter
+ * We add the transpose of <tt>B2</tt> to the upper right block and
* continue in a similar fashion. In the end, the block matrix structure is
- * printed into an LaTeX table. @until latex
+ * printed into an LaTeX table.
+ * @until latex
*
* Now, we set up vectors to be multiplied with this matrix and do a
- * multiplication. @until vmult
+ * multiplication.
+ * @until vmult
*
* Finally, we solve a linear system with BlockMatrixArray, using no
- * preconditioning and the conjugate gradient method. @until Error
+ * preconditioning and the conjugate gradient method.
+ * @until Error
*
* The remaining code of this sample program concerns preconditioning and is
* described in the documentation of BlockTrianglePrecondition.
*
* In order to set up the preconditioner, we have to compute the inverses of
* the diagonal blocks ourselves. Since we used FullMatrix objects, this is
- * fairly easy. @dontinclude block_matrix_array.cc @skip Error @until
- * Cinv.invert
+ * fairly easy.
+ * @dontinclude block_matrix_array.cc
+ * @skip Error
+ * @until Cinv.invert
*
* After creating a <i>2x2</i> BlockTrianglePrecondition object, we only fill
* its diagonals. The scaling factor <i>1/2</i> used for <tt>A</tt> is the
* reciprocal of the scaling factor used for the <tt>matrix</tt> itself.
* Remember, this preconditioner actually <b>multiplies</b> with the diagonal
- * blocks. @until Cinv
+ * blocks.
+ * @until Cinv
*
* Now, we have a block Jacobi preconditioner, which is still symmetric, since
* the blocks are symmetric. Therefore, we can still use the preconditioned
- * conjugate gradient method. @until Error
+ * conjugate gradient method.
+ * @until Error
*
* Now, we enter the subdiagonal block. This is the same as in
- * <tt>matrix</tt>. @until B2
+ * <tt>matrix</tt>.
+ * @until B2
*
* Since the preconditioner is not symmetric anymore, we use the GMRES method
- * for solving. @until Error
+ * for solving.
+ * @until Error
*
*
* @ingroup Preconditioners
operator = (const LAPACKFullMatrix<number> &);
/**
- * Assignment operator from a regular FullMatrix. @note Since LAPACK expects
+ * Assignment operator from a regular FullMatrix.
+ *
+ * @note Since LAPACK expects
* matrices in transposed order, this transposition is included here.
*/
template <typename number2>
operator = (const FullMatrix<number2> &);
/**
- * Assignment operator from a regular SparseMatrix. @note Since LAPACK
+ * Assignment operator from a regular SparseMatrix.
+ *
+ * @note Since LAPACK
* expects matrices in transposed order, this transposition is included
* here.
*/
const size_type cols);
/**
- * Return the dimension of the range space. @note The matrix is of dimension
+ * Return the dimension of the range space.
+ *
+ * @note The matrix is of dimension
* $m \times n$.
*/
unsigned int m () const;
/**
- * Return the number of the range space. @note The matrix is of dimension $m
+ * Return the number of the range space.
+ *
+ * @note The matrix is of dimension $m
* \times n$.
*/
unsigned int n () const;
* stack products of three or more matrices by making one of the two matrices
* an object of the current type handles be a ProductMatrix itself.
*
- * Here is an example multiplying two different FullMatrix objects: @include
- * product_matrix.cc
+ * Here is an example multiplying two different FullMatrix objects:
+ * @include product_matrix.cc
*
* @author Guido Kanschat, 2000, 2001, 2002, 2005
*/
/**
* Assign a new matrix pointer. Deletes the old pointer and releases its
- * matrix. @see SmartPointer
+ * matrix.
+ * @see SmartPointer
*/
const PointerMatrix &operator= (const MATRIX *M);
/**
* Assign a new matrix pointer. Deletes the old pointer and releases its
- * matrix. @see SmartPointer
+ * matrix.
+ * @see SmartPointer
*/
const PointerMatrixAux &operator= (const MATRIX *M);
/**
* Assign a new matrix pointer. Deletes the old pointer and releases its
- * matrix. @see SmartPointer
+ * matrix.
+ * @see SmartPointer
*/
const PointerMatrixVector &operator= (const Vector<number> *M);
/**
* Assign a new matrix pointer. Deletes the old pointer and releases its
- * matrix. @see SmartPointer
+ * matrix.
+ * @see SmartPointer
*/
const TransposeMatrix &operator= (const MATRIX *M);
/**
* Make a sparsity pattern including fluxes of discontinuous Galerkin
- * methods. @see
+ * methods.
+ * @see
* @ref make_sparsity_pattern
* and
* @ref DoFTools
* the general documentation of this class. An example is also provided in
* the documentation of this class's base class DataOut_DoFData.
*
- * @param n_patches_per_circle Denotes into how many intervals
- * the angular (rotation) variable is to be subdivided.
- *
* @param n_subdivisions See DataOut::build_patches() for an extensive
* description of this parameter. The number of subdivisions is always
* one in the direction of the time-like parameter used by this class.
projects / dealii.git / commitdiff