![]() |
Reference documentation for deal.II version 8.1.0
|
#include <tensor.h>
Public Types | |
typedef Tensor< rank_-1, dim, Number > | value_type |
typedef numbers::NumberTraits< Number >::real_type | real_type |
typedef Tensor< rank_-1, dim, Number >::array_type | array_type[dim] |
Public Member Functions | |
Tensor () | |
Tensor (const array_type &initializer) | |
Tensor (const Tensor< 1, dim, Tensor< rank_-1, dim, Number > > &tensor_in) | |
operator Tensor< 1, dim, Tensor< rank_-1, dim, Number > > () const | |
Tensor< rank_-1, dim, Number > & | operator[] (const unsigned int i) |
const Tensor< rank_-1, dim, Number > & | operator[] (const unsigned int i) const |
Number | operator[] (const TableIndices< rank_ > &indices) const |
Number & | operator[] (const TableIndices< rank_ > &indices) |
Tensor & | operator= (const Tensor< rank_, dim, Number > &) |
Tensor< rank_, dim, Number > & | operator= (const Number d) |
bool | operator== (const Tensor< rank_, dim, Number > &) const |
bool | operator!= (const Tensor< rank_, dim, Number > &) const |
Tensor< rank_, dim, Number > & | operator+= (const Tensor< rank_, dim, Number > &) |
Tensor< rank_, dim, Number > & | operator-= (const Tensor< rank_, dim, Number > &) |
Tensor< rank_, dim, Number > & | operator*= (const Number factor) |
Tensor< rank_, dim, Number > & | operator/= (const Number factor) |
Tensor< rank_, dim, Number > | operator+ (const Tensor< rank_, dim, Number > &) const |
Tensor< rank_, dim, Number > | operator- (const Tensor< rank_, dim, Number > &) const |
Tensor< rank_, dim, Number > | operator- () const |
real_type | norm () const |
real_type | norm_square () const |
template<typename Number2 > | |
void | unroll (Vector< Number2 > &result) const |
void | clear () |
DeclException1 (ExcInvalidTensorIndex, int,<< "Invalid tensor index "<< arg1) | |
template<class Archive > | |
void | serialize (Archive &ar, const unsigned int version) |
Static Public Member Functions | |
static unsigned int | component_to_unrolled_index (const TableIndices< rank_ > &indices) |
static TableIndices< rank_ > | unrolled_to_component_indices (const unsigned int i) |
static std::size_t | memory_consumption () |
Static Public Attributes | |
static const unsigned int | dimension = dim |
static const unsigned int | rank = rank_ |
static const unsigned int | n_independent_components = Tensor<rank_-1,dim>::n_independent_components *dim |
Private Member Functions | |
template<typename Number2 > | |
void | unroll_recursion (Vector< Number2 > &result, unsigned int &start_index) const |
Private Attributes | |
Tensor< rank_-1, dim, Number > | subtensor [dim] |
Friends | |
template<int , int , typename > | |
class | Tensor |
Related Functions | |
(Note that these are not member functions.) | |
template<int dim, typename Number > | |
std::ostream & | operator<< (std::ostream &out, const Tensor< 0, dim, Number > &p) |
template<int dim, typename Number > | |
std::ostream & | operator<< (std::ostream &out, const Tensor< 1, dim, Number > &p) |
std::ostream & | operator<< (std::ostream &out, const Tensor< 1, 1, double > &p) |
template<int dim, typename Number > | |
Tensor< 1, dim, Number > | operator* (const Tensor< 1, dim, Number > &t, const Number factor) |
template<int dim, typename Number > | |
Tensor< 1, dim, Number > | operator* (const Number factor, const Tensor< 1, dim, Number > &t) |
template<int dim, typename Number > | |
Tensor< 1, dim, Number > | operator/ (const Tensor< 1, dim, Number > &t, const Number factor) |
template<int dim> | |
Tensor< 1, dim > | operator* (const Tensor< 1, dim > &t, const double factor) |
template<int dim> | |
Tensor< 1, dim > | operator* (const double factor, const Tensor< 1, dim > &t) |
template<int dim> | |
Tensor< 1, dim > | operator/ (const Tensor< 1, dim > &t, const double factor) |
template<int rank_, int dim, typename Number > | |
std::ostream & | operator<< (std::ostream &out, const Tensor< rank_, dim, Number > &p) |
template<int dim, typename Number > | |
Number | contract (const Tensor< 1, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
Number | operator* (const Tensor< 1, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
Number | double_contract (const Tensor< 2, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 1, dim, Number > &dest, const Tensor< 2, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
Tensor< 1, dim, Number > | operator* (const Tensor< 2, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 1, dim, Number > &dest, const Tensor< 1, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
Tensor< 1, dim, Number > | operator* (const Tensor< 1, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 2, dim, Number > &dest, const Tensor< 2, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
Tensor< 2, dim, Number > | operator* (const Tensor< 2, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 2, dim, Number > &dest, const Tensor< 2, dim, Number > &src1, const unsigned int index1, const Tensor< 2, dim, Number > &src2, const unsigned int index2) |
template<int dim, typename Number > | |
void | contract (Tensor< 2, dim, Number > &dest, const Tensor< 3, dim, Number > &src1, const unsigned int index1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 3, dim, Number > &dest, const Tensor< 3, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 3, dim, Number > &dest, const Tensor< 3, dim, Number > &src1, const unsigned int index1, const Tensor< 2, dim, Number > &src2, const unsigned int index2) |
template<int dim, typename Number > | |
Tensor< 3, dim, Number > | operator* (const Tensor< 3, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
void | contract (Tensor< 3, dim, Number > &dest, const Tensor< 2, dim, Number > &src1, const Tensor< 3, dim, Number > &src2) |
template<int dim, typename Number > | |
Tensor< 3, dim, Number > | operator* (const Tensor< 2, dim, Number > &src1, const Tensor< 3, dim, Number > &src2) |
template<int dim, typename Number > | |
Tensor< 4, dim, Number > | operator* (const Tensor< 3, dim, Number > &src1, const Tensor< 3, dim, Number > &src2) |
template<int dim, typename Number > | |
void | double_contract (Tensor< 2, dim, Number > &dest, const Tensor< 4, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
Number | contract3 (const Tensor< 1, dim, Number > &u, const Tensor< 2, dim, Number > &A, const Tensor< 1, dim, Number > &v) |
template<int dim, typename Number > | |
Number | contract3 (const Tensor< 1, dim, Number > &t1, const Tensor< 3, dim, Number > &t2, const Tensor< 2, dim, Number > &t3) |
template<int dim, typename Number > | |
Number | contract3 (const Tensor< 2, dim, Number > &t1, const Tensor< 3, dim, Number > &t2, const Tensor< 1, dim, Number > &t3) |
template<int dim, typename Number > | |
Number | contract3 (const Tensor< 2, dim, Number > &t1, const Tensor< 4, dim, Number > &t2, const Tensor< 2, dim, Number > &t3) |
template<int dim, typename Number > | |
void | outer_product (Tensor< 2, dim, Number > &dst, const Tensor< 1, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
void | outer_product (Tensor< 3, dim, Number > &dst, const Tensor< 1, dim, Number > &src1, const Tensor< 2, dim, Number > &src2) |
template<int dim, typename Number > | |
void | outer_product (Tensor< 3, dim, Number > &dst, const Tensor< 2, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
void | outer_product (Tensor< 1, dim, Number > &dst, const Number src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
void | outer_product (Tensor< 1, dim, Number > &dst, const Tensor< 1, dim, Number > src1, const Number src2) |
template<int dim, typename Number > | |
void | cross_product (Tensor< 1, dim, Number > &dst, const Tensor< 1, dim, Number > &src) |
template<int dim, typename Number > | |
void | cross_product (Tensor< 1, dim, Number > &dst, const Tensor< 1, dim, Number > &src1, const Tensor< 1, dim, Number > &src2) |
template<int dim, typename Number > | |
Number | scalar_product (const Tensor< 2, dim, Number > &t1, const Tensor< 2, dim, Number > &t2) |
template<int rank, typename Number > | |
Number | determinant (const Tensor< rank, 1, Number > &t) |
template<typename Number > | |
Number | determinant (const Tensor< 1, 1, Number > &t) |
template<typename Number > | |
Number | determinant (const Tensor< 2, 1, Number > &t) |
template<typename Number > | |
Number | determinant (const Tensor< 2, 2, Number > &t) |
template<typename Number > | |
Number | determinant (const Tensor< 2, 3, Number > &t) |
template<int dim, typename Number > | |
Number | determinant (const Tensor< 2, dim, Number > &t) |
template<int dim, typename Number > | |
Number | trace (const Tensor< 2, dim, Number > &d) |
template<int dim, typename Number > | |
Tensor< 2, dim, Number > | invert (const Tensor< 2, dim, Number > &t) |
template<int dim, typename Number > | |
Tensor< 2, dim, Number > | transpose (const Tensor< 2, dim, Number > &t) |
template<int dim, typename Number > | |
double | l1_norm (const Tensor< 2, dim, Number > &t) |
template<int dim, typename Number > | |
double | linfty_norm (const Tensor< 2, dim, Number > &t) |
template<int rank, int dim, typename Number > | |
Tensor< rank, dim, Number > | operator* (const Tensor< rank, dim, Number > &t, const Number factor) |
template<int rank, int dim, typename Number > | |
Tensor< rank, dim, Number > | operator* (const Number factor, const Tensor< rank, dim, Number > &t) |
template<int rank, int dim, typename Number > | |
Tensor< rank, dim, Number > | operator/ (const Tensor< rank, dim, Number > &t, const Number factor) |
template<int rank, int dim> | |
Tensor< rank, dim > | operator* (const Tensor< rank, dim > &t, const double factor) |
template<int rank, int dim> | |
Tensor< rank, dim > | operator* (const double factor, const Tensor< rank, dim > &t) |
template<int rank, int dim> | |
Tensor< rank, dim > | operator/ (const Tensor< rank, dim > &t, const double factor) |
Provide a general tensor class with an arbitrary rank, i.e. with an arbitrary number of indices. The Tensor class provides an indexing operator and a bit of infrastructure, but most functionality is recursively handed down to tensors of rank 1 or put into external templated functions, e.g. the contract
family.
Using this tensor class for objects of rank 2 has advantages over matrices in many cases since the dimension is known to the compiler as well as the location of the data. It is therefore possible to produce far more efficient code than for matrices with runtime-dependent dimension.
This class provides an optional template argument for the type of the underlying data. It defaults to double
values. It can be used to base tensors on float
or complex
numbers or any other data type that implements basic arithmetic operations.
Definition at line 48 of file tensor_base.h.
typedef Tensor<rank_-1,dim,Number> Tensor< rank_, dim, Number >::value_type |
typedef numbers::NumberTraits<Number>::real_type Tensor< rank_, dim, Number >::real_type |
Declare a type that has holds real-valued numbers with the same precision as the template argument to this class. For std::complex<number>, this corresponds to type number, and it is equal to Number for all other cases. See also the respective field in Vector<Number>.
This typedef is used to represent the return type of norms.
Constructor. Initialize all entries to zero.
Tensor< rank_, dim, Number >::Tensor | ( | const array_type & | initializer | ) |
Copy constructor, where the data is copied from a C-style array.
Tensor< rank_, dim, Number >::Tensor | ( | const Tensor< 1, dim, Tensor< rank_-1, dim, Number > > & | tensor_in | ) |
Conversion operator from tensor of tensors.
Tensor< rank_, dim, Number >::operator Tensor< 1, dim, Tensor< rank_-1, dim, Number > > | ( | ) | const |
Conversion operator to tensor of tensors.
Tensor<rank_-1,dim,Number>& Tensor< rank_, dim, Number >::operator[] | ( | const unsigned int | i | ) |
Read-Write access operator.
const Tensor<rank_-1,dim,Number>& Tensor< rank_, dim, Number >::operator[] | ( | const unsigned int | i | ) | const |
Read-only access operator.
Number Tensor< rank_, dim, Number >::operator[] | ( | const TableIndices< rank_ > & | indices | ) | const |
Read access using TableIndices indices
Number& Tensor< rank_, dim, Number >::operator[] | ( | const TableIndices< rank_ > & | indices | ) |
Read and write access using TableIndices indices
Tensor& Tensor< rank_, dim, Number >::operator= | ( | const Tensor< rank_, dim, Number > & | ) |
Assignment operator.
Tensor<rank_,dim,Number>& Tensor< rank_, dim, Number >::operator= | ( | const Number | d | ) |
This operator assigns a scalar to a tensor. To avoid confusion with what exactly it means to assign a scalar value to a tensor, zero is the only value allowed for d
, allowing the intuitive notation t=0
to reset all elements of the tensor to zero.
bool Tensor< rank_, dim, Number >::operator== | ( | const Tensor< rank_, dim, Number > & | ) | const |
Test for equality of two tensors.
bool Tensor< rank_, dim, Number >::operator!= | ( | const Tensor< rank_, dim, Number > & | ) | const |
Test for inequality of two tensors.
Tensor<rank_,dim,Number>& Tensor< rank_, dim, Number >::operator+= | ( | const Tensor< rank_, dim, Number > & | ) |
Add another tensor.
Tensor<rank_,dim,Number>& Tensor< rank_, dim, Number >::operator-= | ( | const Tensor< rank_, dim, Number > & | ) |
Subtract another tensor.
Tensor<rank_,dim,Number>& Tensor< rank_, dim, Number >::operator*= | ( | const Number | factor | ) |
Scale the tensor by factor
, i.e. multiply all components by factor
.
Tensor<rank_,dim,Number>& Tensor< rank_, dim, Number >::operator/= | ( | const Number | factor | ) |
Scale the vector by 1/factor
.
Tensor<rank_,dim,Number> Tensor< rank_, dim, Number >::operator+ | ( | const Tensor< rank_, dim, Number > & | ) | const |
Add two tensors. If possible, you should use operator +=
instead since this does not need the creation of a temporary.
Tensor<rank_,dim,Number> Tensor< rank_, dim, Number >::operator- | ( | const Tensor< rank_, dim, Number > & | ) | const |
Subtract two tensors. If possible, you should use operator -=
instead since this does not need the creation of a temporary.
Tensor<rank_,dim,Number> Tensor< rank_, dim, Number >::operator- | ( | ) | const |
Unary minus operator. Negate all entries of a tensor.
real_type Tensor< rank_, dim, Number >::norm | ( | ) | const |
Return the Frobenius-norm of a tensor, i.e. the square root of the sum of squares of all entries.
real_type Tensor< rank_, dim, Number >::norm_square | ( | ) | const |
Return the square of the Frobenius-norm of a tensor, i.e. the sum of squares of all entries.
This function mainly exists because it makes computing the norm simpler recursively, but may also be useful in other contexts.
void Tensor< rank_, dim, Number >::unroll | ( | Vector< Number2 > & | result | ) | const |
Fill a vector with all tensor elements.
This function unrolls all tensor entries into a single, linearly numbered vector. As usual in C++, the rightmost index of the tensor marches fastest.
|
static |
Returns an unrolled index in the range [0,dim^rank-1] for the element of the tensor indexed by the argument to the function.
|
static |
Opposite of component_to_unrolled_index: For an index in the range [0,dim^rank-1], return which set of indices it would correspond to.
void Tensor< rank_, dim, Number >::clear | ( | ) |
Reset all values to zero.
Note that this is partly inconsistent with the semantics of the clear()
member functions of the STL and of several other classes within deal.II which not only reset the values of stored elements to zero, but release all memory and return the object into a virginial state. However, since the size of objects of the present type is determined by its template parameters, resizing is not an option, and indeed the state where all elements have a zero value is the state right after construction of such an object.
|
static |
Determine an estimate for the memory consumption (in bytes) of this object.
Tensor< rank_, dim, Number >::DeclException1 | ( | ExcInvalidTensorIndex | , |
int | , | ||
<< "Invalid tensor index "<< | arg1 | ||
) |
Exception.
void Tensor< rank_, dim, Number >::serialize | ( | Archive & | ar, |
const unsigned int | version | ||
) |
Read or write the data of this object to or from a stream for the purpose of serialization
|
private |
Help function for unroll.
|
related |
Output operator for tensors of rank 0. Since such tensors are scalars, we simply print this one value.
<0,dim,Number>
Definition at line 1309 of file tensor_base.h.
|
related |
Output operator for tensors of rank 1. Print the elements consecutively, with a space in between.
<1,dim,Number>
Definition at line 1325 of file tensor_base.h.
|
related |
Output operator for tensors of rank 1 and dimension 1. This is implemented specialized from the general template in order to avoid a compiler warning that the loop is empty.
<1,dim,Number>
Definition at line 1344 of file tensor_base.h.
|
related |
Multiplication of a tensor of rank 1 with a scalar Number from the right.
<1,dim,Number>
Definition at line 1361 of file tensor_base.h.
|
related |
Multiplication of a tensor of rank 1 with a scalar Number from the left.
<1,dim,Number>
Definition at line 1380 of file tensor_base.h.
|
related |
Division of a tensor of rank 1 by a scalar Number.
<1,dim,Number>
Definition at line 1399 of file tensor_base.h.
|
related |
Multiplication of a tensor of rank 1 with a scalar double from the right.
<1,dim,Number>
Definition at line 1418 of file tensor_base.h.
|
related |
Multiplication of a tensor of rank 1 with a scalar double from the left.
<1,dim,Number>
Definition at line 1437 of file tensor_base.h.
|
related |
Division of a tensor of rank 1 by a scalar double.
<1,dim,Number>
Definition at line 1456 of file tensor_base.h.
|
related |
|
related |
Multiplication operator performing a contraction of the last index of the first argument and the first index of the second argument. This function therefore does the same as the corresponding contract
function, but returns the result as a return value, rather than writing it into the reference given as the first argument to the contract
function.
Note that for the Tensor
class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for symmetric tensors, which does the double contraction.
|
related |
Multiplication operator performing a contraction of the last index of the first argument and the first index of the second argument. This function therefore does the same as the corresponding contract
function, but returns the result as a return value, rather than writing it into the reference given as the first argument to the contract
function.
Note that for the Tensor
class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for symmetric tensors, which does the double contraction.
|
related |
Multiplication operator performing a contraction of the last index of the first argument and the first index of the second argument. This function therefore does the same as the corresponding contract
function, but returns the result as a return value, rather than writing it into the reference given as the first argument to the contract
function.
Note that for the Tensor
class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for symmetric tensors, which does the double contraction.
|
related |
Multiplication operator performing a contraction of the last index of the first argument and the first index of the second argument. This function therefore does the same as the corresponding contract
function, but returns the result as a return value, rather than writing it into the reference given as the first argument to the contract
function.
Note that for the Tensor
class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for symmetric tensors, which does the double contraction.
|
related |
Contract a tensor of rank 2 with a tensor of rank 2. The contraction is performed over index index1
of the first tensor, and index2
of the second tensor. Thus, if index1==2
, index2==1
, the result is the usual contraction, but if for example index1==1
, index2==2
, then the result is dest[i][k] = sum_j src1[j][i] src2[k][j]
.
Note that the number of the index is counted from 1 on, not from zero as usual.
|
related |
Contract a tensor of rank 3 with a tensor of rank 2. The contraction is performed over index index1
of the first tensor, and index2
of the second tensor. Thus, if index1==3
, index2==1
, the result is the usual contraction, but if for example index1==1
, index2==2
, then the result is dest[i][j][k] = sum_l src1[l][i][j] src2[k][l]
.
Note that the number of the index is counted from 1 on, not from zero as usual.
|
related |
Multiplication operator performing a contraction of the last index of the first argument and the first index of the second argument. This function therefore does the same as the corresponding contract
function, but returns the result as a return value, rather than writing it into the reference given as the first argument to the contract
function.
Note that for the Tensor
class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for symmetric tensors, which does the double contraction.
|
related |
Multiplication operator performing a contraction of the last index of the first argument and the first index of the second argument. This function therefore does the same as the corresponding contract
function, but returns the result as a return value, rather than writing it into the reference given as the first argument to the contract
function.
Note that for the Tensor
class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for symmetric tensors, which does the double contraction.
|
related |
Form the outer product of two tensors of rank 0 and 1, i.e. dst[i] = src1 * src2[i]
. Of course, this is only a scaling of src2
, but we consider this an outer product for completeness of these functions and since this is sometimes needed when writing templates that depend on the rank of a tensor, which may sometimes be zero (i.e. a scalar).
|
related |
Form the outer product of two tensors of rank 1 and 0, i.e. dst[i] = src1[i] * src2
. Of course, this is only a scaling of src1
, but we consider this an outer product for completeness of these functions and since this is sometimes needed when writing templates that depend on the rank of a tensor, which may sometimes be zero (i.e. a scalar).
|
related |
Cross-product in 2d. This is just a rotation by 90 degrees clockwise to compute the outer normal from a tangential vector. This function is defined for all space dimensions to allow for dimension independent programming (e.g. within switches over the space dimenion), but may only be called if the actual dimension of the arguments is two (e.g. from the dim==2
case in the switch).
|
related |
Cross-product of 2 vectors in 3d. This function is defined for all space dimensions to allow for dimension independent programming (e.g. within switches over the space dimenion), but may only be called if the actual dimension of the arguments is three (e.g. from the dim==3
case in the switch).
|
related |
Compute the scalar product between two tensors
of rank 2. We don't use
operator*
for this operation since the product between two tensors is usually assumed to be the contraction over the last index of the first tensor and the first index of the second tensor, for example .
|
related |
|
related |
|
related |
|
related |
|
related |
|
related |
|
related |
Return the transpose of the given tensor. Since the compiler can perform the return value optimization, and since the size of the return object is known, it is acceptable to return the result by value, rather than by reference as a parameter. Note that there are specializations of this function for dim==1,2,3
.
|
static |
Provide a way to get the dimension of an object without explicit knowledge of it's data type. Implementation is this way instead of providing a function dimension()
because now it is possible to get the dimension at compile time without the expansion and preevaluation of an inlined function; the compiler may therefore produce more efficient code and you may use this value to declare other data types.