/**
* Set the step number in OutputOperator by shifting an integer value.
*
- * @relates OutputOperator
+ * @relatesalso OutputOperator
*/
template <typename VectorType>
inline
* for all possible types, which makes the copy operation much cleaner
* (thanks to a virtual function, whose cost is negligible in this context).
*
- * @relates AlignedVector
+ * @relatesalso AlignedVector
*/
template <typename T>
class AlignedVectorCopy : private parallel::ParallelForInteger
/**
* Like AlignedVectorCopy, but use move operations instead of copy operations.
*
- * @relates AlignedVector
+ * @relatesalso AlignedVector
*/
template <typename T>
class AlignedVectorMove : private parallel::ParallelForInteger
* appropriate operation since some classes might define only one of those
* two operations.
*
- * @relates AlignedVector
+ * @relatesalso AlignedVector
*/
template <typename T, bool initialize_memory>
class AlignedVectorSet : private parallel::ParallelForInteger
* appropriate operation since some classes might define only one of those
* two operations.
*
- * @relates AlignedVector
+ * @relatesalso AlignedVector
*/
template <typename T, bool initialize_memory>
class AlignedVectorDefaultInitialize : private parallel::ParallelForInteger
/**
* Relational operator == for AlignedVector
*
- * @relates AlignedVector
+ * @relatesalso AlignedVector
*/
template < class T >
bool operator == (const AlignedVector<T> &lhs,
/**
* Relational operator != for AlignedVector
*
- * @relates AlignedVector
+ * @relatesalso AlignedVector
*/
template < class T >
bool operator != (const AlignedVector<T> &lhs,
* In debug mode, we check that the provided iterators represent contiguous
* memory indeed.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename Iterator>
ArrayView<typename std::remove_reference<typename std::iterator_traits<Iterator>::reference>::type>
* @warning The pointers @p begin and @p end must bound (in the usual
* half-open way) a contiguous in memory range of values.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
ArrayView<ElementType>
*
* @param[in] array_view The ArrayView that we wish to make a copy of.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename Number>
inline
*
* @param[in] array_view The ArrayView that we wish to make a copy of.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename Number>
inline
* order in which the entries are presented in the array is undefined and can
* not be relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <int rank, int dim, typename Number>
inline
* order in which the entries are presented in the array is undefined and can
* not be relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <int rank, int dim, typename Number>
inline
* the order in which the entries are presented in the array is undefined and
* can not be relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <int rank, int dim, typename Number>
inline
* order in which the entries are presented in the array is undefined and can
* not be relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <int rank, int dim, typename Number>
inline
* @param[in] array The C-style array for which we want to have an ArrayView
* object. The ArrayView corresponds to the <em>entire</em> vector.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType, int N>
inline
* @param[in] vector The Vector for which we want to have an array view
* object. The array view corresponds to the <em>entire</em> Vector.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* @param[in] vector The Vector for which we want to have an array view
* object. The array view corresponds to the <em>entire</em> Vector.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* @param[in] vector The vector for which we want to have an array view
* object. The array view corresponds to the <em>entire</em> vector.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* @param[in] vector The vector for which we want to have an array view
* object. The array view corresponds to the <em>entire</em> vector.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
*
* @pre <code>starting_index + size_of_view <= vector.size()</code>
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
*
* @pre <code>starting_index + size_of_view <= vector.size()</code>
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* @param[in] row The index of the row into the table to which this view
* should correspond.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* which the entries are presented in the array is undefined and can not be
* relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* which the entries are presented in the array is undefined and can not be
* relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* order in which the entries are presented in the array is undefined and can
* not be relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* order in which the entries are presented in the array is undefined and can
* not be relied upon.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* @param[in] row The index of the row into the table to which this view
* should correspond.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* corresponds to the number of columns in the current row to which the view
* should correspond.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* corresponds to the number of columns in the current row to which the view
* should correspond.
*
- * @relates ArrayView
+ * @relatesalso ArrayView
*/
template <typename ElementType>
inline
* types. Annoyingly, the standard library does not provide such an
* operator...
*
- * @relates ProductType
+ * @relatesalso ProductType
*/
template <typename T, typename U>
typename ProductType<std::complex<T>, std::complex<U> >::type
* floating point type with a different real floating point type. Annoyingly,
* the standard library does not provide such an operator...
*
- * @relates EnableIfScalar
- * @relates ProductType
+ * @relatesalso EnableIfScalar
+ * @relatesalso ProductType
*/
template <typename T, typename U>
typename ProductType<std::complex<T>, typename EnableIfScalar<U>::type>::type
* floating point type with a different complex floating point type.
* Annoyingly, the standard library does not provide such an operator...
*
- * @relates EnableIfScalar
- * @relates ProductType
+ * @relatesalso EnableIfScalar
+ * @relatesalso ProductType
*/
template <typename T, typename U>
typename ProductType<typename EnableIfScalar<T>::type, std::complex<U> >::type
* is what this function does. If @p T is DerivativeForm<1,dim,1> it computes
* $DF * T$, if @p T is DerivativeForm<1,dim,rank> it computes $T*DF^{T}$.
*
- * @relates DerivativeForm
+ * @relatesalso DerivativeForm
* @author Sebastian Pauletti, 2011
*/
template <int spacedim, int dim, typename Number>
/**
* Similar to previous apply_transformation. It computes $T*DF^{T}$.
*
- * @relates DerivativeForm
+ * @relatesalso DerivativeForm
* @author Sebastian Pauletti, 2011
*/
//rank=2
/**
* Similar to previous apply_transformation. It computes $DF2*DF1^{T}$
*
- * @relates DerivativeForm
+ * @relatesalso DerivativeForm
* @author Sebastian Pauletti, 2011
*/
template <int spacedim, int dim, typename Number>
* Transpose of a rectangular DerivativeForm DF, mostly for compatibility
* reasons.
*
- * @relates DerivativeForm
+ * @relatesalso DerivativeForm
* @author Sebastian Pauletti, 2011
*/
template <int dim, int spacedim, typename Number>
/**
* Output shift operator for events. Calls Event::print().
*
- * @relates Event
+ * @relatesalso Event
*/
template <class OS>
OS &operator << (OS &o, const Event &e)
* ...
* @endcode
*
- * @relates IndexSet
+ * @relatesalso IndexSet
*/
inline
IndexSet complete_index_set (const unsigned int N)
/**
* Multiply the current point by a factor.
*
- * @relates EnableIfScalar
+ * @relatesalso EnableIfScalar
*/
template <typename OtherNumber>
Point<dim,typename ProductType<Number, typename EnableIfScalar<OtherNumber>::type>::type>
/**
* Global operator scaling a point vector by a scalar.
*
- * @relates Point
- * @relates EnableIfScalar
+ * @relatesalso Point
+ * @relatesalso EnableIfScalar
*/
template <int dim, typename Number, typename OtherNumber>
inline
/**
* Output operator for points. Print the elements consecutively, with a space
* in between.
- * @relates Point
+ * @relatesalso Point
*/
template <int dim, typename Number>
inline
/**
* Input operator for points. Inputs the elements consecutively.
- * @relates Point
+ * @relatesalso Point
*/
template <int dim, typename Number>
inline
* you should use <tt>operator +=</tt> instead since this does not require the
* creation of a temporary variable.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* you should use <tt>operator +=</tt> instead since this does not require the
* creation of a temporary variable.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* result is a general Tensor that has a number type that is compatible with the
* operation.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* result is a general Tensor that has a number type that is compatible with the
* operation.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* result is a general Tensor that has a number type that is compatible with the
* operation.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* result is a general Tensor that has a number type that is compatible with the
* operation.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* For greater notational simplicity, there is also a <tt>third_invariant</tt>
* function that returns the determinant of a tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* provided for greater notational simplicity (since there are also functions
* first_invariant() and second_invariant()).
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* Compute and return the trace of a tensor of rank 2, i.e. the sum of its
* diagonal entries. The trace is the first invariant of a rank-2 tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* greater notational simplicity (since there are also functions
* second_invariant() and third_invariant()).
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* For the kind of arguments to this function, i.e., a rank-2 tensor of
* size 1, the result is simply zero.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005, 2010
*/
template <typename Number>
* the second and third invariant are the same; the determinant is the third
* invariant.)
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005, 2010
*/
template <typename Number>
* $II(\sigma) = \frac 12 \left[ (\text{trace}\ \sigma)^2
* -\text{trace}\ (\sigma^2) \right]$.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005, 2010
*/
template <typename Number>
* The (single) entry of the tensor is, of course, equal to the (single)
* eigenvalue.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Jean-Paul Pelteret, 2017
*/
template <typename Number>
* As an alternative, the eigenvectors() function provides a more robust, but costly,
* method to compute the eigenvalues of a symmetric tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Jean-Paul Pelteret, 2017
*/
template <typename Number>
* As an alternative, the eigenvectors() function provides a more robust, but costly,
* method to compute the eigenvalues of a symmetric tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Jean-Paul Pelteret, 2017
*/
template <typename Number>
/**
* Return the eigenvalues and eigenvectors of a symmetric 1x1 tensor of rank 2.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Jean-Paul Pelteret, 2017
*/
template <typename Number>
* }
* @endcode
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Joachim Kopp, Jean-Paul Pelteret, 2017
*/
template <int dim, typename Number>
* tensor. This function mainly exists for compatibility with the Tensor
* class.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int rank_, int dim, typename Number>
* quantity equals the original tensor minus its contractive or dilative
* component and refers to the shear in, for example, elasticity.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* Return a unit symmetric tensor of rank 2, i.e., the dim-by-dim identity
* matrix.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* matrix. This specialization of the function uses <code>double</code> as the
* data type for the elements.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim>
* sometimes needs to invert operators like <tt>identity_tensor<dim>() +
* delta_t*deviator_tensor<dim>()</tt> or similar.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* sometimes needs to invert operators like <tt>identity_tensor<dim>() +
* delta_t*deviator_tensor<dim>()</tt> or similar.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim>
*
* This issue is also explained in the introduction to step-44.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* <tt>id_0101=id_0110=1/2</tt>. Similar considerations hold for the three-
* dimensional case.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim>
* likely contain the results of a division by zero or a very small number at
* the very least.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Jean-Paul Pelteret, 2016
*/
template <int dim, typename Number>
* likely contain the results of a division by zero or a very small number at
* the very least.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* unit_symmetric_tensor<dim,Number>())</tt>, since the (double) contraction
* with the unit tensor yields the trace of a symmetric tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number>
* (t+transpose(t))/2, as a symmetric rank-2 tensor. This is the version for
* general dimensions.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim,typename Number>
* right. This version of the operator is used if the scalar has the same data
* type as is used to store the elements of the symmetric tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number>
inline
* left. This version of the operator is used if the scalar has the same data
* type as is used to store the elements of the symmetric tensor.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number>
inline
* the type you would get if you multiplied an individual component of the
* input tensor by the scalar factor.
*
- * @relates SymmetricTensor
- * @relates EnableIfScalar
+ * @relatesalso SymmetricTensor
+ * @relatesalso EnableIfScalar
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* See the discussion with the operator with switched arguments for more
* information about template arguments and the return type.
*
- * @relates SymmetricTensor
- * @relates EnableIfScalar
+ * @relatesalso SymmetricTensor
+ * @relatesalso EnableIfScalar
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
/**
* Division of a symmetric tensor of general rank by a scalar.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim, typename Number, typename OtherNumber>
inline
* Multiplication of a symmetric tensor of general rank with a scalar from the
* right.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim>
inline
* Multiplication of a symmetric tensor of general rank with a scalar from the
* left.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim>
inline
/**
* Division of a symmetric tensor of general rank by a scalar.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int rank_, int dim>
inline
* <code>t1*t2</code> which uses the overloaded <code>operator*</code> between
* two symmetric tensors of rank 2.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int dim, typename Number, typename OtherNumber>
inline
* the contraction over the last index of the first tensor and the first index
* of the second tensor, for example $(a\cdot b)_{ij}=\sum_k a_{ik}b_{kj}$.
*
- * @relates Tensor @relates SymmetricTensor
+ * @relatesalso Tensor @relatesalso SymmetricTensor
*/
template <int dim, typename Number, typename OtherNumber>
inline
* the contraction over the last index of the first tensor and the first index
* of the second tensor, for example $(a\cdot b)_{ij}=\sum_k a_{ik}b_{kj}$.
*
- * @relates Tensor @relates SymmetricTensor
+ * @relatesalso Tensor @relatesalso SymmetricTensor
*/
template <int dim, typename Number, typename OtherNumber>
inline
* Multiply a symmetric rank-2 tensor (i.e., a matrix) by a rank-1 tensor
* (i.e., a vector). The result is a rank-1 tensor (i.e., a vector).
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number, typename OtherNumber>
* Multiply a rank-1 tensor (i.e., a vector) by a symmetric rank-2 tensor
* (i.e., a matrix). The result is a rank-1 tensor (i.e., a vector).
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Wolfgang Bangerth, 2005
*/
template <int dim, typename Number, typename OtherNumber>
* multiplication operator for SymmetricTensor, which does the double
* contraction.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Matthias Maier, Jean-Paul Pelteret, 2017
*/
template <int rank_1, int rank_2, int dim,
* multiplication operator for SymmetricTensor, which does the double
* contraction.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
* @author Matthias Maier, Jean-Paul Pelteret, 2017
*/
template <int rank_1, int rank_2, int dim,
* represents the symmetry in the output, for example by outputting only the
* unique entries.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int dim, typename Number>
inline
* represents the symmetry in the output, for example by outputting only the
* unique entries.
*
- * @relates SymmetricTensor
+ * @relatesalso SymmetricTensor
*/
template <int dim, typename Number>
inline
* forward all elements at the same time, comparing the first element is
* sufficient.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename Iterators>
inline
* objects compared march forward all elements at the same time, differencing
* the first element is sufficient.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename Iterators>
inline
/**
* Advance a tuple of iterators by $n$.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename I1, typename I2>
inline
/**
* Advance a tuple of iterators by $n$.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename I1, typename I2, typename I3>
inline
/**
* Advance a tuple of iterators by $n$.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename I1, typename I2,
typename I3, typename I4>
/**
* Advance a tuple of iterators by 1.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename I1, typename I2>
inline
/**
* Advance a tuple of iterators by 1.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename I1, typename I2, typename I3>
inline
/**
* Advance a tuple of iterators by 1.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename I1, typename I2,
typename I3, typename I4>
/**
* Advance the elements of this iterator by $n$.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename Iterators>
inline
/**
* Advance the elements of this iterator by 1.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename Iterators>
inline
* Compare synch iterators for inequality. Since they march in synch,
* comparing only the first element is sufficient.
*
- * @relates SynchronousIterators
+ * @relatesalso SynchronousIterators
*/
template <typename Iterators>
inline
* Output operator for TableIndices objects; reports them in a list like this:
* <code>[i1,i2,...]</code>.
*
- * @relates TableIndices
+ * @relatesalso TableIndices
*/
template <int N>
std::ostream &
* in between, two spaces between rank 1 subtensors, three between rank 2 and
* so on.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank_, int dim, typename Number>
inline
* Output operator for tensors of rank 0. Since such tensors are scalars, we
* simply print this one value.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number>
inline
* This function unwraps the underlying @p Number stored in the Tensor and
* multiplies @p object with it.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number, typename Other>
inline
* This function unwraps the underlying @p Number stored in the Tensor and
* multiplies @p object with it.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number, typename Other>
inline
* OtherNumber that are stored within the Tensor and multiplies them. It
* returns an unwrapped number of product type.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number, typename OtherNumber>
inline
/**
* Division of a tensor of rank 0 by a scalar number.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number, typename OtherNumber>
inline
/**
* Add two tensors of rank 0.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number, typename OtherNumber>
inline
/**
* Subtract two tensors of rank 0.
*
- * @relates Tensor<0,dim,Number>
+ * @relatesalso Tensor<0,dim,Number>
*/
template <int dim, typename Number, typename OtherNumber>
inline
* number, a complex floating point number, etc.) is allowed, see the
* documentation of EnableIfScalar for details.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank, int dim,
typename Number,
* number, a complex floating point number, etc.) is allowed, see the
* documentation of EnableIfScalar for details.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank, int dim,
typename Number,
* discussion on operator*() above for more information about template
* arguments and the return type.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank, int dim,
typename Number,
*
* @tparam rank The rank of both tensors.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank, int dim, typename Number, typename OtherNumber>
inline
*
* @tparam rank The rank of both tensors.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank, int dim, typename Number, typename OtherNumber>
inline
* @note In case the contraction yields a tensor of rank 0 the scalar number
* is returned as an unwrapped number type.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Matthias Maier, 2015
*/
template <int rank_1, int rank_2, int dim,
* @note In case the contraction yields a tensor of rank 0 the scalar number
* is returned as an unwrapped number type.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Matthias Maier, 2015
*/
template <int index_1, int index_2,
* @note In case the contraction yields a tensor of rank 0 the scalar number
* is returned as an unwrapped number type.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Matthias Maier, 2015
*/
template <int index_1, int index_2, int index_3, int index_4,
* \text{right}_{i_1,\ldots,i_r}
* @f]
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Matthias Maier, 2015
*/
template <int rank, int dim, typename Number, typename OtherNumber>
* @note Each of the three input tensors can be either a Tensor or
* SymmetricTensor.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Matthias Maier, 2015, Jean-Paul Pelteret 2017
*/
template <template <int, int, typename> class TensorT1,
* = \text{left}_{i_1,\ldots,i_{r1}}\,\text{right}_{j_1,\ldots,j_{r2}.}
* @f]
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Matthias Maier, 2015
*/
template <int rank_1, int rank_2, int dim,
* but may only be called if the actual dimension of the arguments is two
* (e.g. from the <tt>dim==2</tt> case in the switch).
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Guido Kanschat, 2001
*/
template <int dim, typename Number>
* actual dimension of the arguments is three (e.g. from the <tt>dim==3</tt>
* case in the switch).
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Guido Kanschat, 2001
*/
template <int dim, typename Number>
/**
* Compute the determinant of a tensor or rank 2.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Wolfgang Bangerth, 2009
*/
template <int dim, typename Number>
/**
* Specialization for dim==1.
*
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <typename Number>
inline
* Compute and return the trace of a tensor of rank 2, i.e. the sum of its
* diagonal entries.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Wolfgang Bangerth, 2001
*/
template <int dim, typename Number>
* object is known, it is acceptable to return the result by value, rather
* than by reference as a parameter.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Wolfgang Bangerth, 2000
*/
template <int dim, typename Number>
/**
* Return the transpose of the given tensor.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Wolfgang Bangerth, 2002
*/
template <int dim, typename Number>
*
* @note This requires that the tensor is invertible.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Jean-Paul Pelteret, 2016
*/
template <int dim, typename Number>
*
* @note This requires that the tensor is invertible.
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Jean-Paul Pelteret, 2016
*/
template <int dim, typename Number>
* Return the $l_1$ norm of the given rank-2 tensor, where $||t||_1 = \max_j
* \sum_i |t_{ij}|$ (maximum of the sums over columns).
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Wolfgang Bangerth, 2012
*/
template <int dim, typename Number>
* Return the $l_\infty$ norm of the given rank-2 tensor, where $||t||_\infty
* = \max_i \sum_j |t_{ij}|$ (maximum of the sums over rows).
*
- * @relates Tensor
+ * @relatesalso Tensor
* @author Wolfgang Bangerth, 2012
*/
template <int dim, typename Number>
*
* @deprecated Use the double_contract() function that takes indices as
* template arguments and returns its result instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
*
* @deprecated Use the double_contract() function that takes indices as
* template arguments and returns its result instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
*
* @deprecated Use the contract() function that takes indices as template
* arguments and returns its result instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
*
* @deprecated Use the contract() function that takes indices as template
* arguments and returns its result instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
*
* @deprecated Use the contract() function that takes indices as template
* arguments and returns its result instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
* rank_2.
*
* @deprecated Use operator* instead. It denotes a single contraction.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank_1, int rank_2, int dim, typename Number>
DEAL_II_DEPRECATED
* Contract a tensor of rank 1 with a tensor of rank 1 and return the result.
*
* @deprecated Use operator* instead. It denotes a single contraction.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number, typename OtherNumber>
DEAL_II_DEPRECATED
* degrees.
*
* @deprecated Use the function cross_product_2d() that returns the value.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
* The cross product of 2 vectors in 3d.
*
* @deprecated Use the function cross_product_3d() that returns the value.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
* Form the outer product of two tensors.
*
* @deprecated Use the generic version that returns its result instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank_1, int rank_2, int dim, typename Number>
DEAL_II_DEPRECATED
* Multiply a Tensor<1,dim,Number> with a Number.
*
* @deprecated Use operator* instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
* Multiply a Tensor<1,dim,Number> with a Number.
*
* @deprecated Use operator* instead.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int dim, typename Number>
DEAL_II_DEPRECATED
/**
* @deprecated Do not use this function, evaluate the value manually.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <int rank, typename Number>
DEAL_II_DEPRECATED
/**
* @deprecated Do not use this function, evaluate the value manually.
- * @relates Tensor
+ * @relatesalso Tensor
*/
template <typename Number>
DEAL_II_DEPRECATED
* Helper function for creating temporary objects without typing template
* arguments.
*
- * @relates VectorSlice
+ * @relatesalso VectorSlice
* @author Guido Kanschat, 2004
*/
template <typename VectorType>
* Helper function for creating temporary objects without typing template
* arguments.
*
- * @relates VectorSlice
+ * @relatesalso VectorSlice
* @author Guido Kanschat, 2004
*/
template <typename VectorType>
* Create a vectorized array that sets all entries in the array to the given
* scalar.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
*
* This is the inverse operation to vectorized_transpose_and_store().
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
*
* This is the inverse operation to vectorized_load_and_transpose().
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
/**
* Relational operator == for VectorizedArray
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
/**
* Addition of two vectorized arrays with operator +.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
/**
* Subtraction of two vectorized arrays with operator -.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
/**
* Multiplication of two vectorized arrays with operator *.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
/**
* Division of two vectorized arrays with operator /.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* Addition of a scalar (expanded to a vectorized array with @p
* n_array_elements equal entries) and a vectorized array.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* is a double (needed in order to be able to write simple code with constants
* that are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Addition of a vectorized array and a scalar (expanded to a vectorized array
* with @p n_array_elements equal entries).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* (needed in order to be able to write simple code with constants that are
* usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Subtraction of a vectorized array from a scalar (expanded to a vectorized
* array with @p n_array_elements equal entries).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* double (needed in order to be able to write simple code with constants that
* are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Subtraction of a scalar (expanded to a vectorized array with @p
* n_array_elements equal entries) from a vectorized array.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* is a double (needed in order to be able to write simple code with constants
* that are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Multiplication of a scalar (expanded to a vectorized array with @p
* n_array_elements equal entries) and a vectorized array.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* is a double (needed in order to be able to write simple code with constants
* that are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Multiplication of a vectorized array and a scalar (expanded to a vectorized
* array with @p n_array_elements equal entries).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* double (needed in order to be able to write simple code with constants that
* are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Quotient between a scalar (expanded to a vectorized array with @p
* n_array_elements equal entries) and a vectorized array.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* is a double (needed in order to be able to write simple code with constants
* that are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
* Quotient between a vectorized array and a scalar (expanded to a vectorized
* array with @p n_array_elements equal entries).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* double (needed in order to be able to write simple code with constants that
* are usually double numbers).
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
inline DEAL_II_ALWAYS_INLINE
VectorizedArray<float>
/**
* Unary operator + on a vectorized array.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
/**
* Unary operator - on a vectorized array.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline DEAL_II_ALWAYS_INLINE
* vectorized array in the form <tt>{sin(x[0]), sin(x[1]), ...,
* sin(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* vectorized array in the form <tt>{cos(x[0]), cos(x[1]), ...,
* cos(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* as vectorized array in the form <tt>{tan(x[0]), tan(x[1]), ...,
* tan(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* returned as vectorized array in the form <tt>{exp(x[0]), exp(x[1]), ...,
* exp(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* returned as vectorized array in the form <tt>{log(x[0]), log(x[1]), ...,
* log(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* returned as vectorized array in the form <tt>{sqrt(x[0]), sqrt(x[1]),
* ..., sqrt(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* field. The result is returned as vectorized array in the form
* <tt>{pow(x[0],p), pow(x[1],p), ..., pow(x[n_array_elements-1],p)}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* result is returned as vectorized array in the form <tt>{abs(x[0]),
* abs(x[1]), ..., abs(x[n_array_elements-1])}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* result is returned as vectorized array in the form <tt>{max(x[0],y[0]),
* max(x[1],y[1]), ...}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
* result is returned as vectorized array in the form <tt>{min(x[0],y[0]),
* min(x[1],y[1]), ...}</tt>.
*
- * @relates VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename Number>
inline
*
* @deprecated Use <code>dh.get_fe_collection().max_dofs_per_cell()</code>.
*
- * @relates DoFHandler
+ * @relatesalso DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().max_dofs_per_cell()</code>.
*
- * @relates hp::DoFHandler
+ * @relatesalso hp::DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().max_dofs_per_face()</code>.
*
- * @relates DoFHandler
+ * @relatesalso DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().max_dofs_per_face()</code>.
*
- * @relates hp::DoFHandler
+ * @relatesalso hp::DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().max_dofs_per_vertex()</code>.
*
- * @relates DoFHandler
+ * @relatesalso DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().max_dofs_per_vertex()</code>.
*
- * @relates hp::DoFHandler
+ * @relatesalso hp::DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().n_components()</code>.
*
- * @relates DoFHandler
+ * @relatesalso DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe_collection().n_components()</code>.
*
- * @relates hp::DoFHandler
+ * @relatesalso hp::DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe(0).is_primitive()</code>.
*
- * @relates DoFHandler
+ * @relatesalso DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
*
* @deprecated Use <code>dh.get_fe(0).is_primitive()</code>.
*
- * @relates hp::DoFHandler
+ * @relatesalso hp::DoFHandler
*/
template <int dim, int spacedim>
DEAL_II_DEPRECATED
/**
* Operator computing the maximum coupling out of two.
*
- * @relates DoFTools
+ * @relatesalso DoFTools
*/
inline
Coupling operator |= (Coupling &c1,
/**
* Operator computing the maximum coupling out of two.
*
- * @relates DoFTools
+ * @relatesalso DoFTools
*/
inline
Coupling operator | (const Coupling c1,
* explicitly specify the type of the base iterator by hand -- it is deduced
* automatically here.
*
- * @author Wolfgang Bangerth @relates FilteredIterator
+ * @author Wolfgang Bangerth @relatesalso FilteredIterator
*/
template <typename BaseIterator, typename Predicate>
FilteredIterator<BaseIterator>
* @endcode
*
* @author Bruno Turcksin, 2016
- * @relates FilteredIterator
+ * @relatesalso FilteredIterator
* @ingroup CPP11
*/
template <typename BaseIterator, typename Predicate>
* @endcode
*
* @author Bruno Turcksin, 2016
- * @relates FilteredIterator
+ * @relatesalso FilteredIterator
* @ingroup CPP11
*/
template <typename BaseIterator, typename Predicate, typename... Targs>
* C++ standard library which uses a temporary object. The function simply
* exchanges the data of the two objects.
*
- * @relates BlockIndices
+ * @relatesalso BlockIndices
* @author Wolfgang Bangerth, 2000
*/
inline
//@{
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A function that encapsulates a @p block_matrix into a BlockLinearOperator.
*
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A variant of above function that encapsulates a given collection @p ops of
* LinearOperators into a block structure. Here, it is assumed that Range and
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* This function extracts the diagonal blocks of @p block_matrix (either a
* block matrix type or a BlockLinearOperator) and creates a
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A variant of above function that builds up a block diagonal linear operator
* from an array @p ops of diagonal elements (off-diagonal blocks are assumed
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A variant of above function that only takes a single LinearOperator
* argument @p op and creates a blockdiagonal linear operator with @p m copies
//@{
/**
- * @relates LinearOperator
- * @relates BlockLinearOperator
+ * @relatesalso LinearOperator
+ * @relatesalso BlockLinearOperator
*
* This function implements forward substitution to invert a lower block
* triangular matrix. As arguments, it takes a BlockLinearOperator @p
/**
- * @relates LinearOperator
- * @relates BlockLinearOperator
+ * @relatesalso LinearOperator
+ * @relatesalso BlockLinearOperator
*
* This function implements back substitution to invert an upper block
* triangular matrix. As arguments, it takes a BlockLinearOperator @p
* standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates BlockVector
+ * @relatesalso BlockVector
* @author Wolfgang Bangerth, 2000
*/
template <typename Number>
* @note Currently, this function may not work correctly for distributed data
* structures.
*
- * @relates LinearOperator
+ * @relatesalso LinearOperator
* @ingroup constraints
*/
template <typename Range, typename Domain>
*
* @author Mauro Bardelloni, Matthias Maier, 2015
*
- * @relates LinearOperator
+ * @relatesalso LinearOperator
* @ingroup constraints
*/
template <typename Range, typename Domain>
* @note Currently, this function may not work correctly for distributed data
* structures.
*
- * @relates LinearOperator
+ * @relatesalso LinearOperator
* @ingroup constraints
*/
template <typename Range, typename Domain>
* @note Currently, this function may not work correctly for distributed data
* structures.
*
- * @relates LinearOperator
+ * @relatesalso LinearOperator
* @ingroup constraints
*/
template <typename Range, typename Domain>
* standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates BlockVector
+ * @relatesalso BlockVector
* @author Katharina Kormann, Martin Kronbichler, 2011
*/
template <typename Number>
* C++ standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates Vector
+ * @relatesalso Vector
* @author Katharina Kormann, Martin Kronbichler, 2011
*/
template <typename Number>
//@{
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Addition of two linear operators @p first_op and @p second_op given by
* $(\text{first\_op}+\text{second\_op})x := \text{first\_op}(x) +
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Subtraction of two linear operators @p first_op and @p second_op given by
* $(\text{first\_op}-\text{second\_op})x := \text{first\_op}(x) -
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Scalar multiplication of a ScalarOperator object @p op with @p number from
* the left.
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Scalar multiplication of a ScalarOperator object from the right.
*
//@{
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Composition of two linear operators @p first_op and @p second_op given by
* $(\text{first\_op}*\text{second\_op})x :=
}
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Return the transpose linear operations of @p op.
*
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Return an object representing the inverse of the LinearOperator @p op.
*
//@{
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Return a LinearOperator that is the identity of the vector space @p Range.
*
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Return a LinearOperator that is the identity of the vector space @p Range.
*
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Return a nulled variant of the LinearOperator @p op, i.e. with optimized
* LinearOperator::vmult, LinearOperator::vmult_add, etc. functions and with
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* A function that encapsulates generic @p matrix objects that act on a
* compatible Vector type into a LinearOperator. The LinearOperator object
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Variant of above function that takes an operator object @p
* operator_exemplar as an additional reference. This object is used to
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Variant of above function that takes a LinearOperator @p
* operator_exemplar as an additional reference.
* order to allow for copying and rearranging. Each matrix block can be
* identified by name.
*
- * @relates MatrixBlock
+ * @relatesalso MatrixBlock
* @ingroup vector_valued
* @author Baerbel Janssen, Guido Kanschat, 2010
*/
* pointers, in order to allow for copying and rearranging. Each matrix block
* can be identified by name.
*
- * @relates MatrixBlock
+ * @relatesalso MatrixBlock
* @ingroup vector_valued
* @author Baerbel Janssen, Guido Kanschat, 2010
*/
//@{
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Addition of two PackagedOperation objects @p first_comp and @p second_comp
* given by vector space addition of the corresponding results.
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Subtraction of two PackagedOperation objects @p first_comp and @p
* second_comp given by vector space addition of the corresponding results.
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Scalar multiplication of a PackagedOperation objects @p comp with a scalar
* @p number given by a scaling PackagedOperation result with @p number.
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Scalar multiplication of a PackagedOperation objects @p comp with a scalar
* @p number given by a scaling PackagedOperation result with @p number.
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Add a constant @p offset (of the @p Range space) to the result of a
* PackagedOperation.
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Add a constant @p offset (of the @p Range space) to the result of a
* PackagedOperation.
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Subtract a constant @p offset (of the @p Range space) from the result of a
* PackagedOperation.
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Subtract a computational result from a constant @p offset (of the @p Range
* space). The result is a PackagedOperation object that applies this
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Create a PackagedOperation object that stores the addition of two vectors.
*
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Create a PackagedOperation object that stores the subtraction of two
* vectors.
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Create a PackagedOperation object that stores the scaling of a vector with
* a @p number.
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Create a PackagedOperation object that stores the scaling of a vector with
* a @p number.
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Create a PackagedOperation object from a LinearOperator and a reference to
* a vector @p u of the Domain space. The object stores the PackagedOperation
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Create a PackagedOperation object from a LinearOperator and a reference to
* a vector @p u of the Range space. The object stores the PackagedOperation
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Composition of a PackagedOperation object with a LinearOperator. The object
* stores the computation $\text{op} \,comp$ (in matrix notation).
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* Composition of a PackagedOperation object with a LinearOperator. The object
* stores the computation $\text{op}^T \,comp$ (in matrix notation).
* standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates PETScWrappers::MPI::BlockVector
+ * @relatesalso PETScWrappers::MPI::BlockVector
* @author Wolfgang Bangerth, 2000
*/
inline
* the C++ standard library which uses a temporary object. The function
* simply exchanges the data of the two vectors.
*
- * @relates PETScWrappers::MPI::Vector
+ * @relatesalso PETScWrappers::MPI::Vector
* @author Wolfgang Bangerth, 2004
*/
inline
* C++ standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates PETScWrappers::VectorBase
+ * @relatesalso PETScWrappers::VectorBase
* @author Wolfgang Bangerth, 2004
*/
inline
* <tt>VectorType</tt> argument is a dummy just used to determine the template
* arguments.
*
- * @relates PointerMatrixBase @relates PointerMatrixAux
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrixAux
*/
template <typename VectorType, typename MatrixType>
inline
/**
* Specialized version for IdentityMatrix.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv>
PointerMatrixBase<Vector<numberv> > *
/**
* Specialized version for FullMatrix.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv, typename numberm>
PointerMatrixBase<Vector<numberv> > *
/**
* Specialized version for LAPACKFullMatrix.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv, typename numberm>
PointerMatrixBase<Vector<numberv> > *
/**
* Specialized version for SparseMatrix.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv, typename numberm>
PointerMatrixBase<Vector<numberv> > *
/**
* Specialized version for BlockSparseMatrix.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename VectorType, typename numberm>
PointerMatrixBase<VectorType> *
/**
* Specialized version for SparseMatrixEZ.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv, typename numberm>
PointerMatrixBase<Vector<numberv> > *
/**
* Specialized version for BlockSparseMatrixEZ.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename VectorType, typename numberm>
PointerMatrixBase<VectorType> *
/**
* Specialized version for BlockMatrixArray.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv, typename numberm, typename BLOCK_VectorType>
PointerMatrixBase<BLOCK_VectorType> *
/**
* Specialized version for TridiagonalMatrix.
*
- * @relates PointerMatrixBase @relates PointerMatrix
+ * @relatesalso PointerMatrixBase @relatesalso PointerMatrix
*/
template <typename numberv, typename numberm>
PointerMatrixBase<Vector<numberv> > *
* C++ standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates Vector
+ * @relatesalso Vector
*/
template <typename Number>
inline
//@{
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* Return a LinearOperator that performs the operations associated with the
* Schur complement. There are two additional helper functions,
//@{
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* For the system of equations
* @f{eqnarray*}{
}
/**
- * @relates PackagedOperation
+ * @relatesalso PackagedOperation
*
* For the system of equations
* @f{eqnarray*}{
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* A function that encapsulates generic @p matrix objects, based on an
* @p operator_exemplar, that act on a compatible Vector type into a
/**
- * @relates LinearOperator
+ * @relatesalso LinearOperator
*
* A function that encapsulates generic @p matrix objects that act on a
* compatible Vector type into a LinearOperator.
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A function that encapsulates a @p block_matrix into a BlockLinearOperator.
*
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A variant of above function that builds up a block diagonal linear operator
* from an array @p ops of diagonal elements (off-diagonal blocks are assumed
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* This function extracts the diagonal blocks of @p block_matrix (either a
* block matrix type or a BlockLinearOperator) and creates a
/**
- * @relates BlockLinearOperator
+ * @relatesalso BlockLinearOperator
*
* A variant of above function that builds up a block diagonal linear operator
* from an array @p ops of diagonal elements (off-diagonal blocks are assumed
* standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates TrilinosWrappers::MPI::BlockVector
+ * @relatesalso TrilinosWrappers::MPI::BlockVector
* @author Martin Kronbichler, Wolfgang Bangerth, 2008
*/
inline
* the C++ standard library which uses a temporary object. The function
* simply exchanges the data of the two vectors.
*
- * @relates TrilinosWrappers::MPI::Vector
+ * @relatesalso TrilinosWrappers::MPI::Vector
* @author Martin Kronbichler, Wolfgang Bangerth, 2008
*/
inline
* C++ standard library which uses a temporary object. The function simply
* exchanges the data of the two vectors.
*
- * @relates Vector
+ * @relatesalso Vector
* @author Wolfgang Bangerth, 2000
*/
template <typename Number>
* @note These hold specifically for the codimension 0 case with a
* Cartesian basis, where the metric tensor is the identity tensor.
*
- * @relates Tensor
- * @relates SymmetricTensor
+ * @relatesalso Tensor
+ * @relatesalso SymmetricTensor
* @author Jean-Paul Pelteret, Andrew McBride, 2016
*/
template <int dim>
projects / dealii.git / commitdiff