FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > Class Template Reference

#include <src/ftensor/src/FTensor/Tensor3/Tensor3_value.hpp>

Inheritance diagram for FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >:

Public Member Functions
template<class... U>
	Tensor3 (U... d)
	Tensor3 ()
T &	operator() (const int N1, const int N2, const int N3)
T	operator() (const int N1, const int N2, const int N3) const
template<char i, char j, char k, int Dim0, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor3_Expr< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim0, Dim1, Dim2, i, j, k > >::type	operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim2 >)
template<char i, char j, char k, int Dim0, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor3_Expr< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim0, Dim1, Dim2, i, j, k > >::type	operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim2 >) const
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim >, T, Dim, i > >::type	operator() (const Index< i, Dim >, const Index< j, Dim >, const Index< j, Dim >) const
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_02< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim >, T, Dim, i > >::type	operator() (const Index< j, Dim >, const Index< i, Dim >, const Index< j, Dim >) const
template<char i, char j, int Dim, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >=Dim2), Tensor1_Expr< Tensor3_contracted_01< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim >, T, Dim2, i > >::type	operator() (const Index< j, Dim >, const Index< j, Dim >, const Index< i, Dim2 >) const
template<char i, char j, int N, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim0 >N &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_rhs_0< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim1, Dim2, i, j > >::type	operator() (const Number< N >, const Index< i, Dim1 >, const Index< j, Dim2 >)
template<char i, char j, int N, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim0 >N &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim1, Dim2, i, j > >::type	operator() (const Number< N >, const Index< i, Dim1 >, const Index< j, Dim2 >) const
template<char i, char j, int N, int Dim0, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_rhs_0< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim0, Dim2, i, j > >::type	operator() (const Index< i, Dim0 >, const Number< N >, const Index< j, Dim2 >)
template<char i, char j, int N, int Dim0, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim0, Dim2, i, j > >::type	operator() (const Index< i, Dim0 >, const Number< N >, const Index< j, Dim2 >) const
template<char i, char j, int N, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Tensor3_number_rhs_2< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim, i, j > >::type	operator() (const Index< i, Dim >, const Index< j, Dim >, const Number< N >)
template<char i, char j, int N, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Tensor3_number_2< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim, i, j > >::type	operator() (const Index< i, Dim >, const Index< j, Dim >, const Number< N >) const
template<char i, int N1, int N2, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_rhs_12< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > >::type	operator() (const Index< i, Dim > index, const Number< N1 >, const Number< N2 >)
template<char i, int N1, int N2, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > >::type	operator() (const Index< i, Dim > index, const Number< N1 >, const Number< N2 >) const
template<char i, int N0, int N2, int Dim>
std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_rhs_12< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type	operator() (const Number< N0 >, const Index< i, Dim > index, const Number< N2 >)
template<char i, int N0, int N2, int Dim>
std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type	operator() (const Number< N0 >, const Index< i, Dim > index, const Number< N2 >) const
template<char i, int N0, int N1, int Dim>
std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_number_rhs_01< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type	operator() (const Number< N0 >, const Number< N1 >, const Index< i, Dim > index)
template<char i, int N0, int N1, int Dim>
std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_number_01< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type	operator() (const Number< N0 >, const Number< N1 >, const Index< i, Dim > index) const
template<char i, char j, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_numeral_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim1, Dim2, i, j > >::type	operator() (const int N, const Index< i, Dim1 >, const Index< j, Dim2 >) const
template<char i, char j, int Dim0, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_numeral_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim0, Dim2, i, j > >::type	operator() (const Index< i, Dim0 >, const int N, const Index< j, Dim2 >) const
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim), Tensor2_symmetric_Expr< Tensor3_numeral_2< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i, j > >::type	operator() (const Index< i, Dim >, const Index< j, Dim >, const int N) const
template<char i, int Dim>
std::enable_if<(Tensor_Dim0 >=Dim), Tensor1_Expr< Tensor3_numeral_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i > >::type	operator() (const Index< i, Dim > index, const int N1, const int N2) const
template<char i, int Dim>
std::enable_if<(Tensor_Dim1 >=Dim), Tensor1_Expr< Tensor3_numeral_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i > >::type	operator() (const int N1, const Index< i, Dim > index, const int N2) const
template<char i, int Dim>
std::enable_if<(Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_numeral_01< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i > >::type	operator() (const int N1, const int N2, const Index< i, Dim > index) const

Private Attributes
T	data [Tensor_Dim0][Tensor_Dim1][Tensor_Dim2]

Detailed Description

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>
class FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >

Examples

EshelbianOperators.cpp, HookeElement.cpp, HookeElement.hpp, PlasticOps.hpp, PlasticOpsGeneric.hpp, PlasticOpsLargeStrains.hpp, and hcurl_check_approx_in_2d.cpp.

Definition at line 12 of file Tensor3_value.hpp.

Constructor & Destructor Documentation

Tensor3() [1/2]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<class... U>

FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::Tensor3

(

U...

d

)

Definition at line 17 of file Tensor3_value.hpp.

                                          : data{d...}
    {
      static_assert(sizeof...(d) == sizeof(data) / sizeof(T),
                    "Incorrect number of Arguments. Constructor should "
                    "initialize the entire Tensor");
    }

Tensor3() [2/2]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::Tensor3

(

)

Definition at line 24 of file Tensor3_value.hpp.

{}

Member Function Documentation

operator()() [1/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim), Tensor1_Expr< Tensor3_numeral_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	index,
		const int	N1,
		const int	N2
	)		const

Definition at line 407 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_numeral_12<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
    }

operator()() [2/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int N1, int N2, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_rhs_12< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	index,
		const Number< N1 >	,
		const Number< N2 >
	)

Definition at line 256 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_rhs_12<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N1, N2>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
    }

operator()() [3/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int N1, int N2, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	index,
		const Number< N1 >	,
		const Number< N2 >
	)		const

Definition at line 270 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_12<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N1, N2>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
    }

operator()() [4/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	,
		const Index< j, Dim >	,
		const Index< j, Dim >
	)		const

Definition at line 103 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_contracted_12<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, Dim>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
    }

operator()() [5/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim), Tensor2_symmetric_Expr< Tensor3_numeral_2< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	,
		const Index< j, Dim >	,
		const int	N
	)		const

Definition at line 388 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_numeral_2<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
        TensorExpr(*this, N));
    }

operator()() [6/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int N, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Tensor3_number_rhs_2< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	,
		const Index< j, Dim >	,
		const Number< N >
	)

Definition at line 220 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_rhs_2<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(*this);
    }

operator()() [7/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int N, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Tensor3_number_2< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim >	,
		const Index< j, Dim >	,
		const Number< N >
	)		const

Definition at line 234 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_2<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
        TensorExpr(*this));
    }

operator()() [8/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, char k, int Dim0, int Dim1, int Dim2>

std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor3_Expr< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim0, Dim1, Dim2, i, j, k > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim0 >	,
		const Index< j, Dim1 >	,
		const Index< k, Dim2 >
	)

Definition at line 69 of file Tensor3_value.hpp.

    {
      return Tensor3_Expr<Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T,
                          Dim0, Dim1, Dim2, i, j, k>(*this);
    }

operator()() [9/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, char k, int Dim0, int Dim1, int Dim2>

std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor3_Expr< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim0, Dim1, Dim2, i, j, k > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim0 >	,
		const Index< j, Dim1 >	,
		const Index< k, Dim2 >
	)		const

Definition at line 81 of file Tensor3_value.hpp.

    {
      return Tensor3_Expr<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, Dim0, Dim1,
        Dim2, i, j, k>(*this);
    }

operator()() [10/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int Dim0, int Dim2>

std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_numeral_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim0, Dim2, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim0 >	,
		const int	N,
		const Index< j, Dim2 >
	)		const

Definition at line 371 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_numeral_0<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T>;
      return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, j>(
        TensorExpr(*this, N));
    }

operator()() [11/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int N, int Dim0, int Dim2>

std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_rhs_0< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim0, Dim2, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim0 >	,
		const Number< N >	,
		const Index< j, Dim2 >
	)

Definition at line 189 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_rhs_0<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N>;
      return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, j>(*this);
    }

operator()() [12/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int N, int Dim0, int Dim2>

std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim0, Dim2, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< i, Dim0 >	,
		const Number< N >	,
		const Index< j, Dim2 >
	)		const

Definition at line 203 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_0<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N>;
      return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, j>(TensorExpr(*this));
    }

operator()() [13/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int Dim>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_02< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< j, Dim >	,
		const Index< i, Dim >	,
		const Index< j, Dim >
	)		const

Definition at line 120 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_contracted_02<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, Dim>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
    }

operator()() [14/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int Dim, int Dim2>

std::enable_if<(Tensor_Dim0 >=Dim &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >=Dim2), Tensor1_Expr< Tensor3_contracted_01< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim >, T, Dim2, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Index< j, Dim >	,
		const Index< j, Dim >	,
		const Index< i, Dim2 >
	)		const

Definition at line 137 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_contracted_01<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, Dim2>;
      return Tensor1_Expr<TensorExpr, T, Dim2, i>(TensorExpr(*this));
    }

operator()() [15/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int Dim1, int Dim2>

std::enable_if<(Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_numeral_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim1, Dim2, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const int	N,
		const Index< i, Dim1 >	,
		const Index< j, Dim2 >
	)		const

Definition at line 355 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_numeral_0<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T>;
      return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, i, j>(
        TensorExpr(*this, N));
    }

operator()() [16/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int Dim>

std::enable_if<(Tensor_Dim1 >=Dim), Tensor1_Expr< Tensor3_numeral_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const int	N1,
		const Index< i, Dim >	index,
		const int	N2
	)		const

Definition at line 424 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_numeral_12<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
    }

operator()() [17/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int Dim>

std::enable_if<(Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_numeral_01< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const int	N1,
		const int	N2,
		const Index< i, Dim >	index
	)		const

Definition at line 439 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_numeral_01<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
    }

operator()() [18/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

T & FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const int	N1,
		const int	N2,
		const int	N3
	)

Definition at line 29 of file Tensor3_value.hpp.

    {
#ifdef FTENSOR_DEBUG
      if(N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0
         || N3 >= Tensor_Dim2 || N3 < 0)
        {
          std::stringstream s;
          s << "Bad index in Tensor3<T," << Tensor_Dim0 << "," << Tensor_Dim1
            << "," << Tensor_Dim2 << ">.operator(" << N1 << "," << N2 << ","
            << N3 << ")" << std::endl;
          throw std::out_of_range(s.str());
        }
#endif
      return data[N1][N2][N3];
    }

operator()() [19/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

T FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const int	N1,
		const int	N2,
		const int	N3
	)		const

Definition at line 45 of file Tensor3_value.hpp.

    {
#ifdef FTENSOR_DEBUG
      if(N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0
         || N3 >= Tensor_Dim2 || N3 < 0)
        {
          std::stringstream s;
          s << "Bad index in Tensor3<T," << Tensor_Dim0 << "," << Tensor_Dim1
            << "," << Tensor_Dim2 << ">.operator(" << N1 << "," << N2 << ","
            << N3 << ") const" << std::endl;
          throw std::out_of_range(s.str());
        }
#endif
      return data[N1][N2][N3];
    }

operator()() [20/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int N, int Dim1, int Dim2>

std::enable_if<(Tensor_Dim0 >N &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_rhs_0< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim1, Dim2, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Number< N >	,
		const Index< i, Dim1 >	,
		const Index< j, Dim2 >
	)

Definition at line 159 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_rhs_0<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N>;
      return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, i, j>(*this);
    }

operator()() [21/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, char j, int N, int Dim1, int Dim2>

std::enable_if<(Tensor_Dim0 >N &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Tensor3_number_0< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N >, T, Dim1, Dim2, i, j > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Number< N >	,
		const Index< i, Dim1 >	,
		const Index< j, Dim2 >
	)		const

Definition at line 173 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_0<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N>;
      return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, i, j>(TensorExpr(*this));
    }

operator()() [22/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int N0, int N2, int Dim>

std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_rhs_12< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Number< N0 >	,
		const Index< i, Dim >	index,
		const Number< N2 >
	)

Definition at line 289 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_rhs_12<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N0, N2>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
    }

operator()() [23/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int N0, int N2, int Dim>

std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Tensor3_number_12< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Number< N0 >	,
		const Index< i, Dim >	index,
		const Number< N2 >
	)		const

Definition at line 303 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_12<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N0, N2>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
    }

operator()() [24/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int N0, int N1, int Dim>

std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_number_rhs_01< Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Number< N0 >	,
		const Number< N1 >	,
		const Index< i, Dim >	index
	)

Definition at line 320 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_rhs_01<
        Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N0, N1>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
    }

operator()() [25/25]

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

template<char i, int N0, int N1, int Dim>

std::enable_if<(Tensor_Dim0 >N0 &&Tensor_Dim1 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_number_01< constTensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::operator()	(	const Number< N0 >	,
		const Number< N1 >	,
		const Index< i, Dim >	index
	)		const

Definition at line 334 of file Tensor3_value.hpp.

    {
      using TensorExpr = Tensor3_number_01<
        const Tensor3<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>, T, N0, N1>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
    }

Member Data Documentation

data

template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>

T FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >::data[Tensor_Dim0][Tensor_Dim1][Tensor_Dim2]

private

Definition at line 14 of file Tensor3_value.hpp.

---

The documentation for this class was generated from the following files:

• src/ftensor/src/FTensor.hpp
• src/ftensor/src/FTensor/Tensor3/Tensor3_value.hpp