v0.13.2
Loading...
Searching...
No Matches
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>

Inheritance diagram for FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >:
[legend]
Collaboration diagram for FTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >:
[legend]

Public Member Functions

template<class... U>
 Tensor4 (U... d)
 
 Tensor4 ()
 
T & operator() (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< constTensor4< 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< constTensor4< 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< constTensor4< 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
EshelbianOperators.cpp, HookeElement.cpp, HookeElement.hpp, PlasticOps.hpp, PlasticOpsLargeStrains.hpp, PlasticOpsSmallStrains.hpp, Remodeling.cpp, and matrix_function.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)
inline

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 }
FTensor::Tensor4::data
T data[Tensor_Dim0][Tensor_Dim1][Tensor_Dim2][Tensor_Dim3]
Definition: Tensor4_value.hpp:20
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

◆ 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 ( )
inline

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>
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 >   
)
inline

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 };
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20

◆ operator()() [2/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< constTensor4< 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
inline

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

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

◆ 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, 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< constTensor4< 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
inline

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 }

◆ 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
inline

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 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 >   
)
inline

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 }

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

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 }

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

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

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()() [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
inline

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 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
inline

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()() [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 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
inline

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

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 }
N2
static Number< 2 > N2
Definition: BasicFeTools.hpp:101
N1
static Number< 1 > N1
Definition: BasicFeTools.hpp:100

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

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 }

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 files:
Generated by Doxygen 1.9.5 and hosted at University of Glasgow