v0.8.23
Public Member Functions | Private Attributes | List of all members
FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > Class Template Reference

#include <src/ftensor/src/FTensor/Tensor4/Tensor4_value.hpp>

Public Member Functions

template<class... U>
 Tensor4 (U... d)
 
 Tensor4 ()
 
Toperator() (const int N1, const int N2, const int N3, const int N4)
 
T operator() (const int N1, const int N2, const int N3, const int N4) const
 
template<char i, char j, char k, char l, int Dim0, int Dim1, int Dim2, int Dim3>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2 &&Tensor_Dim3 >=Dim3), Tensor4_Expr< Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > >::type operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim2 >, const Index< l, Dim3 >)
 
template<char i, char j, char k, char l, int Dim0, int Dim1, int Dim2, int Dim3>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2 &&Tensor_Dim3 >=Dim3), Tensor4_Expr< const Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > >::type operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim2 >, const Index< l, Dim3 >) const
 
template<char i, char j, char k, int Dim0, int Dim1, int Dim23>
auto operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim23 >, const Index< k, Dim23 >) const
 
template<char i, char j, char k, int Dim0, int Dim13, int Dim2>
auto operator() (const Index< i, Dim0 >, const Index< j, Dim13 >, const Index< k, Dim2 >, const Index< j, Dim13 >) const
 
template<char i, char j, char l, int Dim0, int Dim12, int Dim3>
auto operator() (const Index< i, Dim0 >, const Index< j, Dim12 >, const Index< j, Dim12 >, const Index< l, Dim3 >) const
 
template<char i, char j, char k, int Dim03, int Dim1, int Dim2>
auto operator() (const Index< i, Dim03 >, const Index< j, Dim1 >, const Index< k, Dim2 >, const Index< i, Dim03 >) const
 
template<char i, char j, char l, int Dim02, int Dim1, int Dim3>
auto operator() (const Index< i, Dim02 >, const Index< j, Dim1 >, const Index< i, Dim02 >, const Index< l, Dim3 >) const
 
template<char i, char k, char l, int Dim01, int Dim2, int Dim3>
auto operator() (const Index< i, Dim01 >, const Index< i, Dim01 >, const Index< k, Dim2 >, const Index< l, Dim3 >) const
 
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim3>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 > N &&Tensor_Dim3 >=Dim3), Tensor3_Expr< Tensor4_number_rhs_2< Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >, T, N >, T, Dim0, Dim1, Dim3, i, j, k > >::type operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Number< N >, const Index< k, Dim3 >)
 
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim3>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 > N &&Tensor_Dim3 >=Dim3), Tensor3_Expr< Tensor4_number_2< const Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >, T, N >, T, Dim0, Dim1, Dim3, i, j, k > >::type operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Number< N >, const Index< k, Dim3 >) const
 
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2 &&Tensor_Dim3 > N), Tensor3_Expr< Tensor4_number_rhs_3< Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >, T, N >, T, Dim0, Dim1, Dim2, i, j, k > >::type operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim2 >, const Number< N >)
 
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim2>
std::enable_if<(Tensor_Dim0 >=Dim0 &&Tensor_Dim1 >=Dim1 &&Tensor_Dim2 >=Dim2 &&Tensor_Dim3 > N), Tensor3_Expr< Tensor4_number_3< const Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >, T, N >, T, Dim0, Dim1, Dim2, i, j, k > >::type operator() (const Index< i, Dim0 >, const Index< j, Dim1 >, const Index< k, Dim2 >, const Number< N >) const
 

Private Attributes

T data [Tensor_Dim0][Tensor_Dim1][Tensor_Dim2][Tensor_Dim3]
 

Detailed Description

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

Examples
HookeElement.cpp, HookeElement.hpp, and Remodeling.cpp.

Definition at line 18 of file Tensor4_value.hpp.

Constructor & Destructor Documentation

◆ Tensor4() [1/2]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<class... U>
FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::Tensor4 ( U...  d)

Definition at line 24 of file Tensor4_value.hpp.

24  : data{d...}
25  {
26  static_assert(sizeof...(d) == sizeof(data) / sizeof(T),
27  "Incorrect number of Arguments. Constructor should "
28  "initialize the entire Tensor");
29  }
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_Dim0][Tensor_Dim1][Tensor_Dim2][Tensor_Dim3]

◆ Tensor4() [2/2]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::Tensor4 ( )

Definition at line 31 of file Tensor4_value.hpp.

31 {}

Member Function Documentation

◆ operator()() [1/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
T& FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const int  N1,
const int  N2,
const int  N3,
const int  N4 
)

Definition at line 35 of file Tensor4_value.hpp.

36  {
37 #ifdef FTENSOR_DEBUG
38  if(N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0
39  || N3 >= Tensor_Dim2 || N3 < 0 || N4 >= Tensor_Dim3 || N4 < 0)
40  {
41  std::stringstream s;
42  s << "Bad index in Tensor4<T," << Tensor_Dim0 << "," << Tensor_Dim1
43  << "," << Tensor_Dim2 << "," << Tensor_Dim3 << ">.operator(" << N1
44  << "," << N2 << "," << N3 << "," << N4 << ") const" << std::endl;
45  throw std::out_of_range(s.str());
46  }
47 #endif
48  return data[N1][N2][N3][N4];
49  }
T data[Tensor_Dim0][Tensor_Dim1][Tensor_Dim2][Tensor_Dim3]

◆ operator()() [2/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
T FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const int  N1,
const int  N2,
const int  N3,
const int  N4 
) const

Definition at line 51 of file Tensor4_value.hpp.

52  {
53 #ifdef FTENSOR_DEBUG
54  if(N1 >= Tensor_Dim0 || N1 < 0 || N2 >= Tensor_Dim1 || N2 < 0
55  || N3 >= Tensor_Dim2 || N3 < 0 || N4 >= Tensor_Dim3 || N4 < 0)
56  {
57  std::stringstream s;
58  s << "Bad index in Tensor4<T," << Tensor_Dim0 << "," << Tensor_Dim1
59  << "," << Tensor_Dim2 << "," << Tensor_Dim3 << ">.operator(" << N1
60  << "," << N2 << "," << N3 << "," << N4 << ")" << std::endl;
61  throw std::out_of_range(s.str());
62  }
63 #endif
64  return data[N1][N2][N3][N4];
65  }
T data[Tensor_Dim0][Tensor_Dim1][Tensor_Dim2][Tensor_Dim3]

◆ operator()() [3/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, char l, int Dim0, int Dim1, int Dim2, int Dim3>
std::enable_if< (Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1 && Tensor_Dim2 >= Dim2 && Tensor_Dim3 >= Dim3), Tensor4_Expr<Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l> >::type FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Index< k, Dim2 >  ,
const Index< l, Dim3 >   
)

Definition at line 78 of file Tensor4_value.hpp.

80  {
81  return Tensor4_Expr<
82  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
83  Dim0, Dim1, Dim2, Dim3, i, j, k, l>(*this);
84  };

◆ operator()() [4/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, char l, int Dim0, int Dim1, int Dim2, int Dim3>
std::enable_if< (Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1 && Tensor_Dim2 >= Dim2 && Tensor_Dim3 >= Dim3), Tensor4_Expr< const Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l> >::type FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Index< k, Dim2 >  ,
const Index< l, Dim3 >   
) const

Definition at line 94 of file Tensor4_value.hpp.

96  {
97  return Tensor4_Expr<
98  const Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>,
99  T, Dim0, Dim1, Dim2, Dim3, i, j, k, l>(*this);
100  };

◆ operator()() [5/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int Dim0, int Dim1, int Dim23>
auto FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Index< k, Dim23 >  ,
const Index< k, Dim23 >   
) const

Definition at line 107 of file Tensor4_value.hpp.

109  {
110  static_assert(Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1
111  && Tensor_Dim2 >= Dim23 && Tensor_Dim3 >= Dim23,
112  "Incompatible indices");
113 
114  using TensorExpr = Tensor4_contracted_23<
115  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
116  Dim23>;
117  return Tensor2_Expr<TensorExpr, T, Dim0, Dim1, i, j>(TensorExpr(*this));
118  };

◆ operator()() [6/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int Dim0, int Dim13, int Dim2>
auto FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim13 >  ,
const Index< k, Dim2 >  ,
const Index< j, Dim13 >   
) const

Definition at line 122 of file Tensor4_value.hpp.

124  {
125  static_assert(Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim13
126  && Tensor_Dim2 >= Dim2 && Tensor_Dim3 >= Dim13,
127  "Incompatible indices");
128 
129  using TensorExpr = Tensor4_contracted_13<
130  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
131  Dim13>;
132  return Tensor2_Expr<TensorExpr, T, Dim0, Dim2, i, k>(TensorExpr(*this));
133  };

◆ operator()() [7/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char l, int Dim0, int Dim12, int Dim3>
auto FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim12 >  ,
const Index< j, Dim12 >  ,
const Index< l, Dim3 >   
) const

Definition at line 137 of file Tensor4_value.hpp.

139  {
140  static_assert(Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim12
141  && Tensor_Dim2 >= Dim12 && Tensor_Dim3 >= Dim3,
142  "Incompatible indices");
143 
144  using TensorExpr = Tensor4_contracted_12<
145  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
146  Dim12>;
147  return Tensor2_Expr<TensorExpr, T, Dim0, Dim3, i, l>(TensorExpr(*this));
148  };

◆ operator()() [8/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int Dim03, int Dim1, int Dim2>
auto FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim03 >  ,
const Index< j, Dim1 >  ,
const Index< k, Dim2 >  ,
const Index< i, Dim03 >   
) const

Definition at line 152 of file Tensor4_value.hpp.

154  {
155  static_assert(Tensor_Dim0 >= Dim03 && Tensor_Dim1 >= Dim1
156  && Tensor_Dim2 >= Dim2 && Tensor_Dim3 >= Dim03,
157  "Incompatible indices");
158 
159  using TensorExpr = Tensor4_contracted_03<
160  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
161  Dim03>;
162  return Tensor2_Expr<TensorExpr, T, Dim1, Dim2, j, k>(TensorExpr(*this));
163  };

◆ operator()() [9/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char l, int Dim02, int Dim1, int Dim3>
auto FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim02 >  ,
const Index< j, Dim1 >  ,
const Index< i, Dim02 >  ,
const Index< l, Dim3 >   
) const

Definition at line 167 of file Tensor4_value.hpp.

169  {
170  static_assert(Tensor_Dim0 >= Dim02 && Tensor_Dim1 >= Dim1
171  && Tensor_Dim2 >= Dim02 && Tensor_Dim3 >= Dim3,
172  "Incompatible indices");
173 
174  using TensorExpr = Tensor4_contracted_02<
175  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
176  Dim02>;
177  return Tensor2_Expr<TensorExpr, T, Dim1, Dim3, j, l>(TensorExpr(*this));
178  };

◆ operator()() [10/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char k, char l, int Dim01, int Dim2, int Dim3>
auto FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim01 >  ,
const Index< i, Dim01 >  ,
const Index< k, Dim2 >  ,
const Index< l, Dim3 >   
) const

Definition at line 182 of file Tensor4_value.hpp.

184  {
185  static_assert(Tensor_Dim0 >= Dim01 && Tensor_Dim1 >= Dim01
186  && Tensor_Dim2 >= Dim2 && Tensor_Dim3 >= Dim3,
187  "Incompatible indices");
188 
189  using TensorExpr = Tensor4_contracted_01<
190  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T,
191  Dim01>;
192  return Tensor2_Expr<TensorExpr, T, Dim2, Dim3, k, l>(TensorExpr(*this));
193  };

◆ operator()() [11/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim3>
std::enable_if< (Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1 && Tensor_Dim2 > N && Tensor_Dim3 >= Dim3), Tensor3_Expr<Tensor4_number_rhs_2<Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, N>, T, Dim0, Dim1, Dim3, i, j, k> >::type FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Number< N ,
const Index< k, Dim3 >   
)

Definition at line 212 of file Tensor4_value.hpp.

213  {
214  using TensorExpr = Tensor4_number_rhs_2<
215  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, N>;
216  return Tensor3_Expr<TensorExpr, T, Dim0, Dim1, Dim3, i, j, k>(*this);
217  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [12/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim3>
std::enable_if< (Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1 && Tensor_Dim2 > N && Tensor_Dim3 >= Dim3), Tensor3_Expr<Tensor4_number_2<const Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, N>, T, Dim0, Dim1, Dim3, i, j, k> >::type FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Number< N ,
const Index< k, Dim3 >   
) const

Definition at line 227 of file Tensor4_value.hpp.

228  {
229  using TensorExpr = Tensor4_number_2<
230  const Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>,
231  T, N>;
232  return Tensor3_Expr<TensorExpr, T, Dim0, Dim1, Dim3, i, j, k>(
233  TensorExpr(*this));
234  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [13/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim2>
std::enable_if< (Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1 && Tensor_Dim2 >= Dim2 && Tensor_Dim3 > N), Tensor3_Expr<Tensor4_number_rhs_3<Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, N>, T, Dim0, Dim1, Dim2, i, j, k> >::type FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Index< k, Dim2 >  ,
const Number< N  
)

Definition at line 246 of file Tensor4_value.hpp.

247  {
248  using TensorExpr = Tensor4_number_rhs_3<
249  Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, N>;
250  return Tensor3_Expr<TensorExpr, T, Dim0, Dim1, Dim2, i, j, k>(*this);
251  }
const int N
Definition: speed_test.cpp:3

◆ operator()() [14/14]

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
template<char i, char j, char k, int N, int Dim0, int Dim1, int Dim2>
std::enable_if< (Tensor_Dim0 >= Dim0 && Tensor_Dim1 >= Dim1 && Tensor_Dim2 >= Dim2 && Tensor_Dim3 > N), Tensor3_Expr<Tensor4_number_3<const Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>, T, N>, T, Dim0, Dim1, Dim2, i, j, k> >::type FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::operator() ( const Index< i, Dim0 >  ,
const Index< j, Dim1 >  ,
const Index< k, Dim2 >  ,
const Number< N  
) const

Definition at line 261 of file Tensor4_value.hpp.

262  {
263  using TensorExpr = Tensor4_number_3<
264  const Tensor4<T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>,
265  T, N>;
266  return Tensor3_Expr<TensorExpr, T, Dim0, Dim1, Dim2, i, j, k>(
267  TensorExpr(*this));
268  }
const int N
Definition: speed_test.cpp:3

Member Data Documentation

◆ data

template<class T, int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
T FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >::data[Tensor_Dim0][Tensor_Dim1][Tensor_Dim2][Tensor_Dim3]
private

Definition at line 20 of file Tensor4_value.hpp.


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