v0.13.2
Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 > Class Template Reference

#include <src/ftensor/src/FTensor/Dg/Dg_value.hpp>

Inheritance diagram for FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >:
[legend]
Collaboration diagram for FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >:
[legend]

Public Member Functions

template<class... U>
 Dg (U... d)
 
 Dg ()
 
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 Dim01, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim2 >=Dim2), Dg_Expr< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > >::type operator() (const Index< i, Dim01 >, const Index< j, Dim01 >, const Index< k, Dim2 >)
 
template<char i, char j, char k, int Dim01, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim2 >=Dim2), Dg_Expr< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > >::type operator() (const Index< i, Dim01 >, const Index< j, Dim01 >, const Index< k, Dim2 >) const
 
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_12< Dg< T, Tensor_Dim01, 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_Dim01 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_02< Dg< T, Tensor_Dim01, 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 Dim01, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim2 >=Dim2), Tensor1_Expr< Tensor3_contracted_01< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01 >, T, Dim2, i > >::type operator() (const Index< j, Dim01 >, const Index< j, Dim01 >, const Index< i, Dim2 >) const
 
template<char i, char j, int N, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim01 >N &&Tensor_Dim01 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, 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_Dim01 >N &&Tensor_Dim01 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_0< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim0 &&Tensor_Dim01 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, 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_Dim01 >=Dim0 &&Tensor_Dim01 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_0< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Dg_number_rhs_2< Dg< T, Tensor_Dim01, 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_Dim01 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Dg_number_2< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim &&Tensor_Dim01 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, 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_Dim01 >=Dim &&Tensor_Dim01 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_12< constDg< T, Tensor_Dim01, 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_Dim01 >N0 &&Tensor_Dim01 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type operator() (const Number< N0 >, const Index< i, Dim >, const Number< N2 >)
 
template<char i, int N0, int N2, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_12< constDg< T, Tensor_Dim01, 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_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Dg_number_rhs_01< Dg< T, Tensor_Dim01, 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_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Dg_number_01< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type operator() (const Number< N0 >, const Number< N1 >, const Index< i, Dim >) const
 
template<char i, char j, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_numeral_0< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim0 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_numeral_0< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim), Tensor2_symmetric_Expr< Dg_numeral_2< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim), Tensor1_Expr< Dg_numeral_12< constDg< T, Tensor_Dim01, 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_Dim01 >=Dim), Tensor1_Expr< Dg_numeral_12< constDg< T, Tensor_Dim01, 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< Dg_numeral_01< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > >::type operator() (const int N1, const int N2, const Index< i, Dim >) const
 
template<char i, char j, char k, int Dim01, int Dim2>
Dg_Expr< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > operator() (const Index< i, Dim01 > index1, const Index< j, Dim01 > index2, const Index< k, Dim2 > index3)
 
template<char i, char j, char k, int Dim01, int Dim2>
Dg_Expr< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > operator() (const Index< i, Dim01 > index1, const Index< j, Dim01 > index2, const Index< k, Dim2 > index3) const
 
template<char i, char j, int Dim, int Dim12>
Tensor1_Expr< Tensor3_contracted_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim12, i >, T, Dim, i > operator() (const Index< i, Dim > index1, const Index< j, Dim12 > index2, const Index< j, Dim12 > index3) const
 
template<char i, char j, int Dim, int Dim02>
Tensor1_Expr< Tensor3_contracted_02< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim02, i >, T, Dim, i > operator() (const Index< j, Dim02 > index1, const Index< i, Dim > index2, const Index< j, Dim02 > index3) const
 
template<char i, char j, int Dim, int Dim01>
Tensor1_Expr< Tensor3_contracted_01< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, i >, T, Dim, i > operator() (const Index< j, Dim01 > index1, const Index< j, Dim01 > index2, const Index< i, Dim > index3) const
 
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > operator() (const Number< N > n1, const Index< i, Dim0 > index1, const Index< j, Dim1 > index2)
 
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > operator() (const Number< N > n1, const Index< i, Dim0 > index1, const Index< j, Dim1 > index2) const
 
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > operator() (const Index< i, Dim0 > index1, const Number< N > n1, const Index< j, Dim1 > index2)
 
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > operator() (const Index< i, Dim0 > index1, const Number< N > n1, const Index< j, Dim1 > index2) const
 
template<char i, char j, int N, int Dim>
Tensor2_symmetric_Expr< Dg_number_rhs_2< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim, i, j > operator() (const Index< i, Dim > index1, const Index< j, Dim > index2, const Number< N > n1)
 
template<char i, char j, int N, int Dim>
Tensor2_symmetric_Expr< Dg_number_2< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim, i, j > operator() (const Index< i, Dim > index1, const Index< j, Dim > index2, const Number< N > n1) const
 
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > operator() (const Index< i, Dim > index, const Number< N1 > n1, const Number< N2 > n2)
 
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > operator() (const Index< i, Dim > index, const Number< N1 > n1, const Number< N2 > n2) const
 
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > operator() (const Number< N1 > n1, const Index< i, Dim > index, const Number< N2 > n2)
 
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > operator() (const Number< N1 > n1, const Index< i, Dim > index, const Number< N2 > n2) const
 
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_rhs_01< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > operator() (const Number< N1 > n1, const Number< N2 > n2, const Index< i, Dim > index)
 
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_01< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > operator() (const Number< N1 > n1, const Number< N2 > n2, const Index< i, Dim > index) const
 
template<char i, char j, int Dim0, int Dim1>
Tensor2_Expr< Dg_numeral_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim0, Dim1, i, j > operator() (const int N, const Index< i, Dim0 > index1, const Index< j, Dim1 > index2) const
 
template<char i, char j, int Dim0, int Dim1>
Tensor2_Expr< Dg_numeral_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim0, Dim1, i, j > operator() (const Index< i, Dim0 > index1, const int N, const Index< j, Dim1 > index2) const
 
template<char i, char j, int Dim>
Tensor2_symmetric_Expr< Dg_numeral_2< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i, j > operator() (const Index< i, Dim > index1, const Index< j, Dim > index2, const int N) const
 
template<char i, int Dim>
Tensor1_Expr< Dg_numeral_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > operator() (const Index< i, Dim > index, const int N1, const int N2) const
 
template<char i, int Dim>
Tensor1_Expr< Dg_numeral_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > operator() (const int N1, const Index< i, Dim > index, const int N2) const
 
template<char i, int Dim>
Tensor1_Expr< Dg_numeral_01< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > operator() (const int N1, const int N2, const Index< i, Dim > index) const
 

Private Attributes

T data [(Tensor_Dim01 *(Tensor_Dim01+1))/2][Tensor_Dim2]
 

Detailed Description

template<class T, int Tensor_Dim01, int Tensor_Dim2>
class FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >
Examples
EshelbianOperators.cpp, PlasticOps.hpp, and PlasticOpsSmallStrains.hpp.

Definition at line 9 of file Dg_value.hpp.

Constructor & Destructor Documentation

◆ Dg() [1/2]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<class... U>
FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::Dg ( U...  d)
inline

Definition at line 14 of file Dg_value.hpp.

14 : data{d...}
15 {
16 static_assert(sizeof...(d) == sizeof(data) / sizeof(T),
17 "Incorrect number of Arguments. Constructor should "
18 "initialize the entire Tensor");
19 }
FTensor::Dg::data
T data[(Tensor_Dim01 *(Tensor_Dim01+1))/2][Tensor_Dim2]
Definition: Dg_value.hpp:11
T
const double T
Definition: mixed_reac_diff.cpp:158
FTensor::d
const Tensor1_Expr< const dTensor0< T, Dim, i >, typename promote< T, double >::V, Dim, i > d(const Tensor0< T * > &a, const Index< i, Dim > index, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
Definition: dTensor0.hpp:27

◆ Dg() [2/2]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::Dg ( )
inline

Definition at line 21 of file Dg_value.hpp.

21{}

Member Function Documentation

◆ operator()() [1/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int Dim>
Tensor1_Expr< Dg_numeral_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index,
const int  N1,
const int  N2 
) const

Definition at line 316 of file Dg_function_operator.hpp.

318 {
319 using TensorExpr
320 = Dg_numeral_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
321 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
322 }
N2
static Number< 2 > N2
Definition: BasicFeTools.hpp:101
N1
static Number< 1 > N1
Definition: BasicFeTools.hpp:100
Tensor1_Expr
Definition: single.cpp:12

◆ operator()() [2/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim), Tensor1_Expr< Dg_numeral_12< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index,
const int  N1,
const int  N2 
) const
inline

Definition at line 377 of file Dg_value.hpp.

378 {
379 using TensorExpr
380 = Dg_numeral_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
381 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
382 }

◆ operator()() [3/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index,
const Number< N1 >  n1,
const Number< N2 >  n2 
)

Definition at line 178 of file Dg_function_operator.hpp.

181 {
182 using TensorExpr
183 = Dg_number_rhs_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
184 return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
185 }

◆ operator()() [4/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index,
const Number< N1 >  n1,
const Number< N2 >  n2 
) const

Definition at line 191 of file Dg_function_operator.hpp.

194 {
195 using TensorExpr
196 = Dg_number_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
197 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
198 }

◆ operator()() [5/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim01 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index,
const Number< N1 >  ,
const Number< N2 >   
)
inline

Definition at line 238 of file Dg_value.hpp.

239 {
240 using TensorExpr
241 = Dg_number_rhs_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
242 return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
243 }

◆ operator()() [6/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim01 >N1 &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_12< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index,
const Number< N1 >  ,
const Number< N2 >   
) const
inline

Definition at line 251 of file Dg_value.hpp.

253 {
254 using TensorExpr
255 = Dg_number_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
256 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
257 }

◆ operator()() [7/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim>
Tensor2_symmetric_Expr< Dg_numeral_2< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index1,
const Index< j, Dim >  index2,
const int  N 
) const

Definition at line 297 of file Dg_function_operator.hpp.

300 {
301 using TensorExpr = Dg_numeral_2<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
302 return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
303 TensorExpr(*this, N));
304 }
N
const int N
Definition: speed_test.cpp:3

◆ operator()() [8/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim>
Tensor2_symmetric_Expr< Dg_number_rhs_2< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index1,
const Index< j, Dim >  index2,
const Number< N >  n1 
)

Definition at line 146 of file Dg_function_operator.hpp.

149 {
150 using TensorExpr = Dg_number_rhs_2<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
151 return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(*this);
152 }

◆ operator()() [9/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim>
Tensor2_symmetric_Expr< Dg_number_2< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index1,
const Index< j, Dim >  index2,
const Number< N >  n1 
) const

Definition at line 158 of file Dg_function_operator.hpp.

161 {
162 using TensorExpr
163 = Dg_number_2<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
164 return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(TensorExpr(*this));
165 }

◆ operator()() [10/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim, int Dim12>
Tensor1_Expr< Tensor3_contracted_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim12, i >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  index1,
const Index< j, Dim12 >  index2,
const Index< j, Dim12 >  index3 
) const

Definition at line 40 of file Dg_function_operator.hpp.

43 {
44 using TensorExpr
45 = Tensor3_contracted_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim12,
46 i>;
47 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
48 }
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27

◆ operator()() [11/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  ,
const Index< j, Dim >  ,
const Index< j, Dim >   
) const
inline

Definition at line 97 of file Dg_value.hpp.

99 {
100 using TensorExpr
101 = Tensor3_contracted_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim>;
102 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
103 }

◆ operator()() [12/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim), Tensor2_symmetric_Expr< Dg_numeral_2< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  ,
const Index< j, Dim >  ,
const int  N 
) const
inline

Definition at line 359 of file Dg_value.hpp.

360 {
361 using TensorExpr
362 = Dg_numeral_2<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
363 return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
364 TensorExpr(*this, N));
365 }

◆ operator()() [13/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Dg_number_rhs_2< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  ,
const Index< j, Dim >  ,
const Number< N >   
)
inline

Definition at line 205 of file Dg_value.hpp.

206 {
207 using TensorExpr
208 = Dg_number_rhs_2<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
209 return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(*this);
210 }

◆ operator()() [14/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim2 >N), Tensor2_symmetric_Expr< Dg_number_2< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim >  ,
const Index< j, Dim >  ,
const Number< N >   
) const
inline

Definition at line 218 of file Dg_value.hpp.

219 {
220 using TensorExpr
221 = Dg_number_2<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
222 return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
223 TensorExpr(*this));
224 }

◆ operator()() [15/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim0, int Dim1>
Tensor2_Expr< Dg_numeral_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim0, Dim1, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim0 >  index1,
const int  N,
const Index< j, Dim1 >  index2 
) const

Definition at line 283 of file Dg_function_operator.hpp.

286 {
287 using TensorExpr = Dg_numeral_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
288 return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(TensorExpr(*this, N));
289 }

◆ operator()() [16/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim0 >  index1,
const Number< N >  n1,
const Index< j, Dim1 >  index2 
)

Definition at line 119 of file Dg_function_operator.hpp.

122 {
123 using TensorExpr = Dg_number_rhs_0<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
124 return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(*this);
125 }

◆ operator()() [17/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim0 >  index1,
const Number< N >  n1,
const Index< j, Dim1 >  index2 
) const

Definition at line 131 of file Dg_function_operator.hpp.

134 {
135 using TensorExpr
136 = Dg_number_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
137 return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(TensorExpr(*this));
138 }

◆ operator()() [18/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim0, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim0 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_numeral_0< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim0, Dim2, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim0 >  ,
const int  N,
const Index< j, Dim2 >   
) const
inline

Definition at line 343 of file Dg_value.hpp.

344 {
345 using TensorExpr
346 = Dg_numeral_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
347 return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, j>(
348 TensorExpr(*this, N));
349 }

◆ operator()() [19/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim0, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim0 &&Tensor_Dim01 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim2, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim0 >  ,
const Number< N >  ,
const Index< j, Dim2 >   
)
inline

Definition at line 177 of file Dg_value.hpp.

178 {
179 using TensorExpr
180 = Dg_number_rhs_0<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
181 return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, j>(*this);
182 }

◆ operator()() [20/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim0, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim0 &&Tensor_Dim01 >N &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_0< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim2, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim0 >  ,
const Number< N >  ,
const Index< j, Dim2 >   
) const
inline

Definition at line 189 of file Dg_value.hpp.

191 {
192 using TensorExpr
193 = Dg_number_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
194 return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, j>(TensorExpr(*this));
195 }

◆ operator()() [21/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, char k, int Dim01, int Dim2>
Dg_Expr< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< k, Dim2 >  index3 
)

Definition at line 14 of file Dg_function_operator.hpp.

17 {
18 return Dg_Expr<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>(
19 *this);
20 }
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20

◆ operator()() [22/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, char k, int Dim01, int Dim2>
Dg_Expr< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< k, Dim2 >  index3 
) const

Definition at line 25 of file Dg_function_operator.hpp.

28 {
29 return Dg_Expr<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i,
30 j, k>(*this);
31 }

◆ operator()() [23/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, char k, int Dim01, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim2 >=Dim2), Dg_Expr< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim01 >  ,
const Index< j, Dim01 >  ,
const Index< k, Dim2 >   
)
inline

Definition at line 67 of file Dg_value.hpp.

69 {
70 return Dg_Expr<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i, j, k>(
71 *this);
72 }

◆ operator()() [24/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, char k, int Dim01, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim2 >=Dim2), Dg_Expr< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< i, Dim01 >  ,
const Index< j, Dim01 >  ,
const Index< k, Dim2 >   
) const
inline

Definition at line 78 of file Dg_value.hpp.

80 {
81 return Dg_Expr<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim01, Dim2, i,
82 j, k>(*this);
83 }

◆ operator()() [25/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim &&Tensor_Dim2 >=Dim), Tensor1_Expr< Tensor3_contracted_02< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< j, Dim >  ,
const Index< i, Dim >  ,
const Index< j, Dim >   
) const
inline

Definition at line 113 of file Dg_value.hpp.

115 {
116 using TensorExpr
117 = Tensor3_contracted_02<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim>;
118 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
119 }

◆ operator()() [26/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim, int Dim01>
Tensor1_Expr< Tensor3_contracted_01< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, i >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< j, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< i, Dim >  index3 
) const

Definition at line 70 of file Dg_function_operator.hpp.

73 {
74 using TensorExpr
75 = Tensor3_contracted_01<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim01,
76 i>;
77 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
78 }

◆ operator()() [27/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim01, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim2 >=Dim2), Tensor1_Expr< Tensor3_contracted_01< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim01 >, T, Dim2, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< j, Dim01 >  ,
const Index< j, Dim01 >  ,
const Index< i, Dim2 >   
) const
inline

Definition at line 129 of file Dg_value.hpp.

131 {
132 using TensorExpr
133 = Tensor3_contracted_01<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim01>;
134 return Tensor1_Expr<TensorExpr, T, Dim2, i>(TensorExpr(*this));
135 }

◆ operator()() [28/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim, int Dim02>
Tensor1_Expr< Tensor3_contracted_02< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, Dim02, i >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Index< j, Dim02 >  index1,
const Index< i, Dim >  index2,
const Index< j, Dim02 >  index3 
) const

Definition at line 55 of file Dg_function_operator.hpp.

58 {
59 using TensorExpr
60 = Tensor3_contracted_02<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, Dim02,
61 i>;
62 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
63 }

◆ operator()() [29/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim0, int Dim1>
Tensor2_Expr< Dg_numeral_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim0, Dim1, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N,
const Index< i, Dim0 >  index1,
const Index< j, Dim1 >  index2 
) const

Definition at line 269 of file Dg_function_operator.hpp.

272 {
273 using TensorExpr = Dg_numeral_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
274 return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(TensorExpr(*this, N));
275 }

◆ operator()() [30/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim01 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_numeral_0< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim1, Dim2, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N,
const Index< i, Dim1 >  ,
const Index< j, Dim2 >   
) const
inline

Definition at line 328 of file Dg_value.hpp.

329 {
330 using TensorExpr
331 = Dg_numeral_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
332 return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, i, j>(
333 TensorExpr(*this, N));
334 }

◆ operator()() [31/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int Dim>
Tensor1_Expr< Dg_numeral_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N1,
const Index< i, Dim >  index,
const int  N2 
) const

Definition at line 332 of file Dg_function_operator.hpp.

334 {
335 using TensorExpr
336 = Dg_numeral_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
337 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
338 }

◆ operator()() [32/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim), Tensor1_Expr< Dg_numeral_12< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N1,
const Index< i, Dim >  index,
const int  N2 
) const
inline

Definition at line 393 of file Dg_value.hpp.

394 {
395 using TensorExpr
396 = Dg_numeral_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
397 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
398 }

◆ operator()() [33/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int Dim>
Tensor1_Expr< Dg_numeral_01< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N1,
const int  N2,
const Index< i, Dim >  index 
) const

Definition at line 346 of file Dg_function_operator.hpp.

348 {
349 using TensorExpr
350 = Dg_numeral_01<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
351 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
352 }

◆ operator()() [34/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int Dim>
std::enable_if<(Tensor_Dim2 >=Dim), Tensor1_Expr< Dg_numeral_01< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N1,
const int  N2,
const Index< i, Dim >   
) const
inline

Definition at line 407 of file Dg_value.hpp.

408 {
409 using TensorExpr
410 = Dg_numeral_01<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T>;
411 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this, N1, N2));
412 }

◆ operator()() [35/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
T & FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N1,
const int  N2,
const int  N3 
)
inline

Definition at line 26 of file Dg_value.hpp.

27 {
28#ifdef FTENSOR_DEBUG
29 if(N1 >= Tensor_Dim01 || N1 < 0 || N2 >= Tensor_Dim01 || N2 < 0
30 || N3 >= Tensor_Dim2 || N3 < 0)
31 {
32 std::stringstream s;
33 s << "Bad index in Dg<T," << Tensor_Dim01 << "," << Tensor_Dim2
34 << ">.operator(" << N1 << "," << N2 << "," << N3 << ")"
35 << std::endl;
36 throw std::out_of_range(s.str());
37 }
38#endif
39 return N1 > N2 ? data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2][N3]
40 : data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2][N3];
41 }

◆ operator()() [36/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
T FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const int  N1,
const int  N2,
const int  N3 
) const
inline

Definition at line 43 of file Dg_value.hpp.

44 {
45#ifdef FTENSOR_DEBUG
46 if(N1 >= Tensor_Dim01 || N1 < 0 || N2 >= Tensor_Dim01 || N2 < 0
47 || N3 >= Tensor_Dim2 || N3 < 0)
48 {
49 std::stringstream s;
50 s << "Bad index in Dg<T," << Tensor_Dim01 << "," << Tensor_Dim2
51 << ">.operator(" << N1 << "," << N2 << "," << N3 << ") const"
52 << std::endl;
53 throw std::out_of_range(s.str());
54 }
55#endif
56 return N1 > N2 ? data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2][N3]
57 : data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2][N3];
58 }

◆ operator()() [37/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N >  n1,
const Index< i, Dim0 >  index1,
const Index< j, Dim1 >  index2 
)

Definition at line 92 of file Dg_function_operator.hpp.

95 {
96 using TensorExpr = Dg_number_rhs_0<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
97 return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(*this);
98 }

◆ operator()() [38/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim0, int Dim1>
Tensor2_Expr< Dg_number_0< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim0, Dim1, i, j > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N >  n1,
const Index< i, Dim0 >  index1,
const Index< j, Dim1 >  index2 
) const

Definition at line 104 of file Dg_function_operator.hpp.

107 {
108 using TensorExpr
109 = Dg_number_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
110 return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(TensorExpr(*this));
111 }

◆ operator()() [39/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim01 >N &&Tensor_Dim01 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_rhs_0< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim1, Dim2, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N >  ,
const Index< i, Dim1 >  ,
const Index< j, Dim2 >   
)
inline

Definition at line 150 of file Dg_value.hpp.

151 {
152 using TensorExpr
153 = Dg_number_rhs_0<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
154 return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, i, j>(*this);
155 }

◆ operator()() [40/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, char j, int N, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim01 >N &&Tensor_Dim01 >=Dim1 &&Tensor_Dim2 >=Dim2), Tensor2_Expr< Dg_number_0< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N >, T, Dim1, Dim2, i, j > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N >  ,
const Index< i, Dim1 >  ,
const Index< j, Dim2 >   
) const
inline

Definition at line 162 of file Dg_value.hpp.

164 {
165 using TensorExpr
166 = Dg_number_0<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N>;
167 return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, i, j>(TensorExpr(*this));
168 }

◆ operator()() [41/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N0, int N2, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_12< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N0 >  ,
const Index< i, Dim >  index,
const Number< N2 >   
) const
inline

Definition at line 281 of file Dg_value.hpp.

283 {
284 using TensorExpr
285 = Dg_number_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N0, N2>;
286 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
287 }
N0
static Number< 0 > N0
Definition: BasicFeTools.hpp:99

◆ operator()() [42/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N0, int N2, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim &&Tensor_Dim2 >N2), Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N0, N2 >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N0 >  ,
const Index< i, Dim >  ,
const Number< N2 >   
)
inline

Definition at line 268 of file Dg_value.hpp.

269 {
270 using TensorExpr
271 = Dg_number_rhs_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N0, N2>;
272 return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
273 }

◆ operator()() [43/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N0, int N1, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Dg_number_rhs_01< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N0 >  ,
const Number< N1 >  ,
const Index< i, Dim >  index 
)
inline

Definition at line 296 of file Dg_value.hpp.

297 {
298 using TensorExpr
299 = Dg_number_rhs_01<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N0, N1>;
300 return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
301 }

◆ operator()() [44/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N0, int N1, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim2 >=Dim), Tensor1_Expr< Dg_number_01< constDg< T, Tensor_Dim01, Tensor_Dim2 >, T, N0, N1 >, T, Dim, i > >::type FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N0 >  ,
const Number< N1 >  ,
const Index< i, Dim >   
) const
inline

Definition at line 309 of file Dg_value.hpp.

310 {
311 using TensorExpr
312 = Dg_number_01<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N0, N1>;
313 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
314 }

◆ operator()() [45/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_rhs_12< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N1 >  n1,
const Index< i, Dim >  index,
const Number< N2 >  n2 
)

Definition at line 208 of file Dg_function_operator.hpp.

211 {
212 using TensorExpr
213 = Dg_number_rhs_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
214 return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
215 }

◆ operator()() [46/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_12< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N1 >  n1,
const Index< i, Dim >  index,
const Number< N2 >  n2 
) const

Definition at line 221 of file Dg_function_operator.hpp.

224 {
225 using TensorExpr
226 = Dg_number_12<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
227 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
228 }

◆ operator()() [47/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_rhs_01< Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N1 >  n1,
const Number< N2 >  n2,
const Index< i, Dim >  index 
)

Definition at line 236 of file Dg_function_operator.hpp.

239 {
240 using TensorExpr
241 = Dg_number_rhs_01<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
242 return Tensor1_Expr<TensorExpr, T, Dim, i>(*this);
243 }

◆ operator()() [48/48]

template<class T , int Tensor_Dim01, int Tensor_Dim2>
template<char i, int N1, int N2, int Dim>
Tensor1_Expr< Dg_number_01< const Dg< T, Tensor_Dim01, Tensor_Dim2 >, T, N1, N2 >, T, Dim, i > FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::operator() ( const Number< N1 >  n1,
const Number< N2 >  n2,
const Index< i, Dim >  index 
) const

Definition at line 249 of file Dg_function_operator.hpp.

252 {
253 using TensorExpr
254 = Dg_number_01<const Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
255 return Tensor1_Expr<TensorExpr, T, Dim, i>(TensorExpr(*this));
256 }

Member Data Documentation

◆ data

template<class T , int Tensor_Dim01, int Tensor_Dim2>
T FTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 >::data[(Tensor_Dim01 *(Tensor_Dim01+1))/2][Tensor_Dim2]
private

Definition at line 11 of file Dg_value.hpp.

The documentation for this class was generated from the following files:
Generated by Doxygen 1.9.5 and hosted at University of Glasgow