v0.8.15
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>

Public Member Functions

template<class... U>
 Dg (U... d)
 
 Dg ()
 
T & operator() (const int N1, const int N2, const int N3)
 
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< const 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 >) 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< const 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 >) 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< const 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 >) 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< const 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 >) 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< const 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 >) 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< const Dg< 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< const Dg< 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< const Dg< 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< const Dg< 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< const Dg< 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< const Dg< 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< const Dg< 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< const Dg< 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

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 >

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)

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  }
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
T data[(Tensor_Dim01 *(Tensor_Dim01+1))/2][Tensor_Dim2]
Definition: Dg_value.hpp:11

◆ Dg() [2/2]

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

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, 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 15 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  }

◆ operator()() [2/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 26 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()() [3/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 
)

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  }
T data[(Tensor_Dim01 *(Tensor_Dim01+1))/2][Tensor_Dim2]
Definition: Dg_value.hpp:11

◆ operator()() [4/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 41 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  }

◆ operator()() [5/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

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  }
T data[(Tensor_Dim01 *(Tensor_Dim01+1))/2][Tensor_Dim2]
Definition: Dg_value.hpp:11

◆ operator()() [6/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 56 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()() [7/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 >   
)

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()() [8/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 71 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()() [9/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<const 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 >   
) const

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()() [10/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 93 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  }
const int N
Definition: speed_test.cpp:3

◆ 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

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 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 105 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [13/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

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()() [14/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 120 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [15/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

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()() [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_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 132 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [17/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 147 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [18/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 >   
)

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [19/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 159 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [20/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<const 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 >   
) const

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [21/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 >   
)

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [22/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 179 of file Dg_function_operator.hpp.

181  {
182  using TensorExpr
183  = Dg_number_rhs_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
185  }

◆ operator()() [23/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<const 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 >   
) const

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [24/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 192 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()() [25/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  
)

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [26/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 209 of file Dg_function_operator.hpp.

211  {
212  using TensorExpr
213  = Dg_number_rhs_12<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
215  }

◆ operator()() [27/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<const 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  
) const

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [28/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 222 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()() [29/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 237 of file Dg_function_operator.hpp.

239  {
240  using TensorExpr
241  = Dg_number_rhs_01<Dg<T, Tensor_Dim01, Tensor_Dim2>, T, N1, N2>;
243  }

◆ operator()() [30/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 >   
)

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>;
243  }

◆ operator()() [31/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 250 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  }

◆ operator()() [32/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<const 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 >   
) const

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()() [33/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 >   
)

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>;
273  }

◆ operator()() [34/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 270 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [35/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<const 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 >  index,
const Number< N2 >   
) const

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  }

◆ operator()() [36/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 284 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [37/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 
)

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>;
301  }

◆ operator()() [38/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 298 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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [39/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<const 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 >   
) const

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()() [40/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 317 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  }

◆ operator()() [41/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<const Dg<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

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [42/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 333 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()() [43/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<const Dg<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

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [44/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 347 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()() [45/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<const Dg<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

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  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [46/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<const Dg<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

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()() [47/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<const Dg<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

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()() [48/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<const Dg<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

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  }

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: