v0.7.2
Classes | Enumerations | Functions
FTensor Namespace Reference

JSON compatible output. More...

Classes

class  Christof
 
class  Christof< T *, Tensor_Dim0, Tensor_Dim12 >
 
class  Christof_constructor
 
class  Christof_constructor< T, 2, 2 >
 
class  Christof_constructor< T, 3, 3 >
 
class  Christof_constructor< T, 3, 4 >
 
class  Christof_constructor< T, 4, 4 >
 
class  Christof_Expr
 
class  Christof_number_0
 
class  Christof_numeral_0
 
class  Christof_numeral_1
 
class  conj_Tensor2
 
class  d_boundary_Tensor0
 
class  d_boundary_Tensor2_symmetric
 
class  d_one_sided_Tensor1
 
class  d_one_sided_Tensor2_symmetric
 
class  dd_boundary_Tensor0
 
class  dd_boundary_Tensor2_symmetric
 
class  Ddg
 
class  Ddg< T *, Tensor_Dim01, Tensor_Dim23 >
 
class  Ddg_and_Ddg0213
 
class  Ddg_and_Ddg0321
 
class  Ddg_and_Tensor2_symmetric_01
 
class  Ddg_and_Tensor2_symmetric_23
 
class  Ddg_carat_Ddg_13
 
class  Ddg_carat_Tensor2_symmetric_13
 
class  Ddg_Expr
 
class  Ddg_Expr< Ddg< A, Tensor_Dim01, Tensor_Dim23 >, T, Dim01, Dim23, i, j, k, l >
 
class  Ddg_minus_Ddg
 
class  Ddg_mod_Ddg
 
class  Ddg_mod_Tensor2_symmetric_01
 
class  Ddg_mod_Tensor2_symmetric_23
 
class  Ddg_number_0
 
class  Ddg_number_01
 
class  Ddg_number_rhs_0
 
class  Ddg_number_rhs_01
 
class  Ddg_numeral_0
 
class  Ddg_numeral_01
 
class  Ddg_numeral_02
 
class  Ddg_numeral_123
 
class  Ddg_numeral_23
 
class  Ddg_or_Ddg
 
class  Ddg_or_Tensor2_symmetric_13
 
class  Ddg_plus_Ddg
 
class  Ddg_plus_Ddg_2301
 
class  Ddg_times_generic
 
class  Ddg_times_Tensor1_2
 
class  Ddg_times_Tensor2_0_0
 
class  Ddg_times_Tensor2_0_1
 
class  Ddg_times_Tensor2_1_0
 
class  Ddg_times_Tensor2_1_1
 
class  Ddg_times_Tensor2_23
 
class  Ddg_times_Tensor2_2_0
 
class  Ddg_times_Tensor2_2_1
 
class  Ddg_times_Tensor2_32
 
class  Ddg_times_Tensor2_3_0
 
class  Ddg_times_Tensor2_3_1
 
class  Ddg_times_Tensor2_symmetric_01
 
class  Ddg_times_Tensor2_symmetric_13
 
class  Ddg_times_Tensor2_symmetric_23
 
class  ddTensor0
 
class  ddTensor1
 
class  ddTensor2_symmetric
 
class  Dg
 
class  Dg< T *, Tensor_Dim01, Tensor_Dim2 >
 
class  Dg_and_Dg_02
 
class  Dg_and_Dg_12
 
class  Dg_and_Tensor1
 
class  Dg_and_Tensor2_symmetric
 
class  Dg_constructor
 
class  Dg_constructor< T, 2, 2 >
 
class  Dg_constructor< T, 3, 3 >
 
class  Dg_constructor< T, 4, 3 >
 
class  Dg_constructor< T, 4, 4 >
 
class  Dg_divide_generic
 
class  Dg_Expr
 
class  Dg_Expr< Christof< A, Tensor_Dim0, Tensor_Dim12 >, T, Dim12, Dim0, i, j, k >
 
class  Dg_Expr< const Christof< A, Tensor_Dim0, Tensor_Dim12 >, T, Dim12, Dim0, i, j, k >
 
class  Dg_Expr< Ddg_number_rhs_0< A, T, N0 >, T, Dim23, Dim1, i, j, k >
 
class  Dg_Expr< Dg< A, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k >
 
class  Dg_minus_Dg
 
class  Dg_minus_Dg_02
 
class  Dg_number_0
 
class  Dg_number_01
 
class  Dg_number_12
 
class  Dg_number_2
 
class  Dg_number_rhs_0
 
class  Dg_number_rhs_01
 
class  Dg_number_rhs_12
 
class  Dg_number_rhs_2
 
class  Dg_numeral_0
 
class  Dg_numeral_01
 
class  Dg_numeral_12
 
class  Dg_numeral_2
 
class  Dg_or_Dg_02
 
class  Dg_or_Dg_12
 
class  Dg_plus_Dg
 
class  Dg_plus_Dg_10
 
class  Dg_plus_Dg_210
 
class  Dg_times_Dg_12_01
 
class  Dg_times_Dg_12_20
 
class  Dg_times_Dg_2
 
class  Dg_times_generic
 
class  Dg_times_Tensor1_0
 
class  Dg_times_Tensor1_1
 
class  Dg_times_Tensor1_2
 
class  Dg_times_Tensor2_0
 
class  Dg_times_Tensor2_01
 
class  Dg_times_Tensor2_02
 
class  Dg_times_Tensor2_1
 
class  Dg_times_Tensor2_10
 
class  Dg_times_Tensor2_12
 
class  Dg_times_Tensor2_1_0
 
class  Dg_times_Tensor2_1_1
 
class  Dg_times_Tensor2_20
 
class  Dg_times_Tensor2_21
 
class  Dg_times_Tensor2_symmetric_0
 
class  Dg_times_Tensor2_symmetric_01
 
class  Dg_times_Tensor2_symmetric_02
 
class  Dg_times_Tensor2_symmetric_1
 
class  Dg_times_Tensor2_symmetric_10
 
class  Dg_times_Tensor2_symmetric_12
 
class  Dg_times_Tensor2_symmetric_1_0
 
class  Dg_times_Tensor2_symmetric_1_1
 
class  Dg_times_Tensor2_symmetric_20
 
class  Dg_times_Tensor2_symmetric_21
 
class  diffusion_Tensor1
 
class  diffusion_Tensor2_symmetric
 
class  dTensor0
 
class  dTensor1
 
class  dTensor2_symmetric
 
class  generic_minus_Tensor1
 
class  generic_minus_Tensor2_symmetric
 
class  Index
 
class  interpolate_Tensor1
 
class  interpolate_Tensor2_symmetric
 
class  Levi_Civita
 
class  minus_Ddg
 
class  minus_Dg
 
class  minus_Tensor1
 
class  minus_Tensor2
 
class  minus_Tensor2_symmetric
 
class  Number
 
class  PackPtr
 
class  promote
 
class  Riemann
 
class  Riemann< T, 3 >
 
class  Riemann_Expr
 
class  Riemann_Expr< Riemann< A, Dim >, T, Dim, i, j, k, l >
 
class  Riemann_minus_Riemann
 
class  Riemann_plus_Riemann
 
class  Riemann_times_Tensor1_0
 
class  Riemann_times_Tensor1_1
 
class  Riemann_times_Tensor1_2
 
class  Riemann_times_Tensor1_3
 
class  Riemann_times_Tensor2_symmetric_0
 
class  Tensor0
 
class  Tensor0< PackPtr< T *, I > >
 
class  Tensor0< T * >
 
class  Tensor1
 
class  Tensor1< PackPtr< T *, I >, Tensor_Dim >
 
class  Tensor1< T *, Tensor_Dim >
 
class  Tensor1_and_Tensor1
 
class  Tensor1_carat_Tensor1
 
class  Tensor1_constructor
 
class  Tensor1_constructor< T, 1 >
 
class  Tensor1_constructor< T, 2 >
 
class  Tensor1_constructor< T, 3 >
 
class  Tensor1_constructor< T, 4 >
 
class  Tensor1_divide_generic
 
class  Tensor1_Expr
 
class  Tensor1_Expr< Dg_number_rhs_01< A, T, N1, N2 >, T, Dim, i >
 
class  Tensor1_Expr< Dg_number_rhs_12< A, T, N1, N2 >, T, Dim, i >
 
class  Tensor1_Expr< Tensor1< A, Tensor_Dim >, T, Dim, i >
 
class  Tensor1_Expr< Tensor2_number_rhs_0< A, T, N >, T, Dim1, i >
 
class  Tensor1_Expr< Tensor2_number_rhs_1< A, T, N >, T, Dim1, i >
 
class  Tensor1_minus_generic
 
class  Tensor1_minus_Tensor1
 
class  Tensor1_or_Tensor1
 
class  Tensor1_plus_generic
 
class  Tensor1_plus_Tensor1
 
class  Tensor1_times_generic
 
class  Tensor1_times_Tensor1
 
class  Tensor2
 
class  Tensor2< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1, layout >
 
class  Tensor2< T *, Tensor_Dim0, Tensor_Dim1, layout >
 
class  Tensor2_and_Tensor1_0
 
class  Tensor2_and_Tensor1_1
 
class  Tensor2_antisymmetric
 
class  Tensor2_antisymmetric_constructor
 
class  Tensor2_antisymmetric_constructor< T, 2 >
 
class  Tensor2_antisymmetric_constructor< T, 3 >
 
class  Tensor2_antisymmetric_constructor< T, 4 >
 
class  Tensor2_antisymmetric_Expr
 
class  Tensor2_antisymmetric_Expr< Tensor2_antisymmetric< A, Tensor_Dim >, T, Dim, i, j >
 
class  Tensor2_carat_Tensor2_00
 
class  Tensor2_carat_Tensor2_01
 
class  Tensor2_carat_Tensor2_10
 
class  Tensor2_carat_Tensor2_11
 
class  Tensor2_constructor
 
class  Tensor2_constructor< T, 1, 2, column_major >
 
class  Tensor2_constructor< T, 1, 2, row_major >
 
class  Tensor2_constructor< T, 2, 1, column_major >
 
class  Tensor2_constructor< T, 2, 1, row_major >
 
class  Tensor2_constructor< T, 2, 2, column_major >
 
class  Tensor2_constructor< T, 2, 2, row_major >
 
class  Tensor2_constructor< T, 3, 2, column_major >
 
class  Tensor2_constructor< T, 3, 2, row_major >
 
class  Tensor2_constructor< T, 3, 3, column_major >
 
class  Tensor2_constructor< T, 3, 3, row_major >
 
class  Tensor2_constructor< T, 4, 4, column_major >
 
class  Tensor2_constructor< T, 4, 4, row_major >
 
class  Tensor2_divide_generic
 
class  Tensor2_Expr
 
class  Tensor2_Expr< Dg_number_rhs_0< A, T, N >, T, Dim0, Dim1, i, j >
 
class  Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1, layout >, T, Dim0, Dim1, i, j >
 
class  Tensor2_minus_Tensor2_01
 
class  Tensor2_minus_Tensor2_10
 
class  Tensor2_minus_Tensor2_symmetric_01
 
class  Tensor2_minus_Tensor2_symmetric_10
 
class  Tensor2_number_0
 
class  Tensor2_number_1
 
class  Tensor2_number_rhs_0
 
class  Tensor2_number_rhs_1
 
class  Tensor2_numeral_0
 
class  Tensor2_numeral_1
 
class  Tensor2_or_Tensor2
 
class  Tensor2_or_Tensor2_switched
 
class  Tensor2_plus_Tensor2_01
 
class  Tensor2_plus_Tensor2_10
 
class  Tensor2_symmetric
 
class  Tensor2_symmetric< T *, Tensor_Dim >
 
class  Tensor2_symmetric_and_Tensor2_symmetric_01
 
class  Tensor2_symmetric_and_Tensor2_symmetric_10
 
class  Tensor2_symmetric_carat_Tensor2_00
 
class  Tensor2_symmetric_carat_Tensor2_01
 
class  Tensor2_symmetric_carat_Tensor2_10
 
class  Tensor2_symmetric_carat_Tensor2_11
 
class  Tensor2_symmetric_constructor
 
class  Tensor2_symmetric_constructor< T, 1 >
 
class  Tensor2_symmetric_constructor< T, 2 >
 
class  Tensor2_symmetric_constructor< T, 3 >
 
class  Tensor2_symmetric_constructor< T, 4 >
 
class  Tensor2_symmetric_divide_generic
 
class  Tensor2_symmetric_Expr
 
class  Tensor2_symmetric_Expr< Ddg_number_rhs_01< A, T, N0, N1 >, T, Dim, i, j >
 
class  Tensor2_symmetric_Expr< Dg_number_rhs_2< A, T, N >, T, Dim, i, j >
 
class  Tensor2_symmetric_Expr< Tensor2_symmetric< A, Tensor_Dim >, T, Dim, i, j >
 
class  Tensor2_symmetric_minus_generic
 
class  Tensor2_symmetric_minus_Tensor2_01
 
class  Tensor2_symmetric_minus_Tensor2_10
 
class  Tensor2_symmetric_minus_Tensor2_symmetric_01
 
class  Tensor2_symmetric_minus_Tensor2_symmetric_10
 
class  Tensor2_symmetric_mod_Tensor2_symmetric_01
 
class  Tensor2_symmetric_mod_Tensor2_symmetric_10
 
class  Tensor2_symmetric_plus_generic
 
class  Tensor2_symmetric_plus_Tensor2_01
 
class  Tensor2_symmetric_plus_Tensor2_10
 
class  Tensor2_symmetric_plus_Tensor2_symmetric_01
 
class  Tensor2_symmetric_plus_Tensor2_symmetric_10
 
class  Tensor2_symmetric_times_generic
 
class  Tensor2_symmetric_times_Tensor1
 
class  Tensor2_symmetric_times_Tensor1_0
 
class  Tensor2_symmetric_times_Tensor1_1
 
class  Tensor2_symmetric_times_Tensor2_00
 
class  Tensor2_symmetric_times_Tensor2_01
 
class  Tensor2_symmetric_times_Tensor2_10
 
class  Tensor2_symmetric_times_Tensor2_11
 
class  Tensor2_symmetric_times_Tensor2_symmetric
 
class  Tensor2_symmetric_times_Tensor2_symmetric_00
 
class  Tensor2_symmetric_times_Tensor2_symmetric_01
 
class  Tensor2_symmetric_times_Tensor2_symmetric_10
 
class  Tensor2_symmetric_times_Tensor2_symmetric_11
 
class  Tensor2_times_generic
 
class  Tensor2_times_Tensor1
 
class  Tensor2_times_Tensor1_0
 
class  Tensor2_times_Tensor1_1
 
class  Tensor2_times_Tensor2
 
class  Tensor2_times_Tensor2_00
 
class  Tensor2_times_Tensor2_01
 
class  Tensor2_times_Tensor2_10
 
class  Tensor2_times_Tensor2_11
 
class  Tensor3
 
class  Tensor3< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >
 
class  Tensor3< T *, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >
 
class  Tensor3_antisymmetric
 
class  Tensor3_antisymmetric< T *, Tensor_Dim0, Tensor_Dim12 >
 
class  Tensor3_antisymmetric_constructor
 
class  Tensor3_antisymmetric_constructor< T, 2, 2 >
 
class  Tensor3_antisymmetric_constructor< T, 3, 3 >
 
class  Tensor3_antisymmetric_constructor< T, 4, 4 >
 
class  Tensor3_antisymmetric_Expr
 
class  Tensor3_antisymmetric_Expr< Tensor3_antisymmetric< A, Dim0, Dim12 >, T, Dim0, Dim12, i, j, k >
 
class  Tensor3_antisymmetric_mod_Tensor1
 
class  Tensor3_antisymmetric_or_Tensor3_antisymmetric
 
class  Tensor3_antisymmetric_plus_Tensor3_antisymmetric
 
class  Tensor3_antisymmetric_plus_Tensor3_antisymmetric_12
 
class  Tensor3_antisymmetric_times_generic
 
class  Tensor3_constructor
 
class  Tensor3_constructor< T, 2, 2, 2 >
 
class  Tensor3_constructor< T, 3, 3, 3 >
 
class  Tensor3_constructor< T, 4, 4, 4 >
 
class  Tensor3_contracted_01
 
class  Tensor3_contracted_02
 
class  Tensor3_contracted_12
 
class  Tensor3_Expr
 
class  Tensor3_Expr< Tensor3< A, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim0, Dim1, Dim2, i, j, k >
 
class  Tensor3_minus_Tensor3
 
class  Tensor3_minus_Tensor3_10
 
class  Tensor3_minus_Tensor3_120
 
class  Tensor3_minus_Tensor3_201
 
class  Tensor3_minus_Tensor3_21
 
class  Tensor3_minus_Tensor3_210
 
class  Tensor3_number_0
 
class  Tensor3_number_01
 
class  Tensor3_number_02
 
class  Tensor3_number_1
 
class  Tensor3_number_12
 
class  Tensor3_number_2
 
class  Tensor3_number_rhs_0
 
class  Tensor3_number_rhs_01
 
class  Tensor3_number_rhs_02
 
class  Tensor3_number_rhs_1
 
class  Tensor3_number_rhs_12
 
class  Tensor3_number_rhs_2
 
class  Tensor3_numeral_0
 
class  Tensor3_numeral_01
 
class  Tensor3_numeral_12
 
class  Tensor3_numeral_2
 
class  Tensor3_or_Tensor3_02
 
class  Tensor3_or_Tensor3_12
 
class  Tensor3_plus_Tensor3
 
class  Tensor3_plus_Tensor3_10
 
class  Tensor3_plus_Tensor3_120
 
class  Tensor3_plus_Tensor3_201
 
class  Tensor3_plus_Tensor3_21
 
class  Tensor3_plus_Tensor3_210
 
class  Tensor3_times_Dg
 
class  Tensor3_times_Dg_02_20
 
class  Tensor3_times_generic
 
class  Tensor3_times_Tensor1_0
 
class  Tensor3_times_Tensor1_1
 
class  Tensor3_times_Tensor1_2
 
class  Tensor3_times_Tensor2_01
 
class  Tensor3_times_Tensor2_02
 
class  Tensor3_times_Tensor2_0_01
 
class  Tensor3_times_Tensor2_0_10
 
class  Tensor3_times_Tensor2_12
 
class  Tensor3_times_Tensor2_1_01
 
class  Tensor3_times_Tensor2_1_10
 
class  Tensor3_times_Tensor2_2_01
 
class  Tensor3_times_Tensor2_2_10
 
class  Tensor3_times_Tensor2_symmetric_01
 
class  Tensor3_times_Tensor2_symmetric_02
 
class  Tensor3_times_Tensor2_symmetric_12
 
class  Tensor3_times_Tensor3_21
 
class  Tensor4
 
class  Tensor4< T *, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >
 
class  Tensor4_constructor
 
class  Tensor4_constructor< T, 2, 2, 2, 2 >
 
class  Tensor4_constructor< T, 3, 3, 3, 3 >
 
class  Tensor4_contracted_02
 
class  Tensor4_Expr
 
class  Tensor4_Expr< Tensor4< A, Dim0, Dim1, Dim2, Dim3 >, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l >
 
class  Tensor4_minus_Tensor4
 
class  Tensor4_minus_Tensor4_0132
 
class  Tensor4_minus_Tensor4_0213
 
class  Tensor4_minus_Tensor4_0312
 
class  Tensor4_minus_Tensor4_0321
 
class  Tensor4_minus_Tensor4_3201
 
class  Tensor4_plus_Tensor4
 
class  Tensor4_plus_Tensor4_0132
 
class  Tensor4_plus_Tensor4_0213
 
class  Tensor4_plus_Tensor4_0312
 
class  Tensor4_plus_Tensor4_0321
 
class  Tensor4_plus_Tensor4_3201
 
class  Tensor4_times_Tensor1_0
 
class  Tensor4_times_Tensor1_1
 
class  Tensor4_times_Tensor1_2
 
class  Tensor4_times_Tensor1_3
 
class  Tensor4_times_Tensor2_03
 
class  Tensor4_times_Tensor2_0_0
 
class  Tensor4_times_Tensor2_0_1
 
class  Tensor4_times_Tensor2_13
 
class  Tensor4_times_Tensor2_1_0
 
class  Tensor4_times_Tensor2_1_1
 
class  Tensor4_times_Tensor2_23
 
class  Tensor4_times_Tensor2_2_0
 
class  Tensor4_times_Tensor2_2_1
 
class  Tensor4_times_Tensor2_30
 
class  Tensor4_times_Tensor2_32
 
class  Tensor4_times_Tensor2_3_0
 
class  Tensor4_times_Tensor2_3_1
 
class  Tensor4_times_Tensor2_symmetric_02
 
class  Tensor4_times_Tensor2_symmetric_03
 
class  Tensor4_times_Tensor2_symmetric_23
 
class  Tensor4_times_Tensor2_symmetric_30
 
class  Tensor4_times_Tensor2_symmetric_32
 
class  Tensor_Levi_Civita
 
class  transform_Tensor2
 

Enumerations

enum  Layout { column_major, row_major }
 

Functions

template<class A , class B , class T , class U , char i, char j, char k>
auto cross (const Tensor1_Expr< A, T, 3, i > &a, const Tensor1_Expr< B, U, 3, j > &b, const Index< k, 3 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Ddg_and_Ddg0321< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator && (const Ddg_Expr< A, T, Dim, Dim, i, k, j, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, l, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Ddg_and_Ddg0213< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator && (const Ddg_Expr< A, T, Dim, Dim, i, k, l, j > &a, const Ddg_Expr< B, U, Dim, Dim, i, l, k, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_and_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator & (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_and_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator & (const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_and_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator & (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim01, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_and_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator & (const Tensor2_symmetric_Expr< B, U, Dim01, k, l > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim23, char i, char j, char k, char l, char m, char n>
const Ddg_Expr< const Ddg_carat_Ddg_13< A, B, T, U, Dim, Dim23, i, j, k, l, m, n >, typename promote< T, U >::V, Dim, Dim23, i, k, m, n > operator^ (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim23, j, l, m, n > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_carat_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, k > operator^ (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_carat_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_symmetric_Expr< B, U, Dim, j, l > &b, const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a)
 
template<class A , class B , class U , int Current_Dim0, int Current_Dim1, int Current_Dim2, int Current_Dim3, int Dim01, int Dim23, char i, char j, char k, char l>
void T4ddg_equals_T4ddg (A &iter, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Current_Dim1, int Current_Dim2, int Current_Dim3, int Dim01, int Dim23, char i, char j, char k, char l>
void T4ddg_equals_T4ddg (A &iter, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Current_Dim2, int Current_Dim3, int Dim01, int Dim23, char i, char j, char k, char l>
void T4ddg_equals_T4ddg (A &iter, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Current_Dim3, int Dim01, int Dim23, char i, char j, char k, char l>
void T4ddg_equals_T4ddg (A &iter, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim01, int Dim23, char i, char j, char k, char l>
void T4ddg_equals_T4ddg (A &iter, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_minus_Ddg< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator- (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Ddg_mod_Ddg< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator% (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, l, k, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_mod_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator% (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_mod_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator% (const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_mod_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator% (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim01, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_mod_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator% (const Tensor2_symmetric_Expr< B, U, Dim01, k, l > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_or_Ddg< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, k, j, l > operator|| (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, l, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_or_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, k > operator| (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_or_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, k > operator| (const Tensor2_symmetric_Expr< B, U, Dim, j, l > &b, const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_plus_Ddg< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator+ (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_plus_Ddg_2301< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator+ (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Ddg_Expr< B, U, Dim23, Dim01, k, l, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l, int Current_Dim0, int Current_Dim1, int Current_Dim2, int Current_Dim3>
const promote< T, U >::V T4ddg_times_T4ddg_0213 (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l, int Current_Dim1, int Current_Dim2, int Current_Dim3>
const promote< T, U >::V T4ddg_times_T4ddg_0213 (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l, int Current_Dim2, int Current_Dim3>
const promote< T, U >::V T4ddg_times_T4ddg_0213 (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l, int Current_Dim3>
const promote< T, U >::V T4ddg_times_T4ddg_0213 (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const promote< T, U >::V T4ddg_times_T4ddg_0213 (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const promote< T, U >::V operator* (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b)
 
template<class A , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_times_generic< A, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const U &d0)
 
template<class A , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const Ddg_times_generic< A, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, k, l > operator* (const U &d0, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Dg_Expr< const Ddg_times_Tensor1_2< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim23, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Dg_Expr< const Ddg_times_Tensor1_2< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim23, i, j, l > operator* (const Tensor1_Expr< B, U, Dim23, k > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, i, j > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim23, Dim23, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, i, j > operator* (const Tensor2_Expr< B, U, Dim23, Dim23, k, l > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_32< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, i, j > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim23, Dim23, l, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_32< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, i, j > operator* (const Tensor2_Expr< B, U, Dim23, Dim23, l, k > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_3_1< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, k, m > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim23, Dim4, l, m > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_3_1< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, k, m > operator* (const Tensor2_Expr< B, U, Dim23, Dim4, l, m > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_3_0< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, k, m > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim4, Dim23, m, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_3_0< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, k, m > operator* (const Tensor2_Expr< B, U, Dim4, Dim23, m, l > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_2_0< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, m, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim4, Dim23, m, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_2_0< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, m, l > operator* (const Tensor2_Expr< B, U, Dim4, Dim23, m, k > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_2_1< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, m, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim4, Dim23, k, m > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_2_1< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim4, i, j, m, l > operator* (const Tensor2_Expr< B, U, Dim4, Dim23, k, m > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim2, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_1_0< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim2, Dim23, Dim23, i, m, k, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim01, Dim2, j, m > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim2, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_1_0< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim2, Dim23, Dim23, i, m, k, l > operator* (const Tensor2_Expr< B, U, Dim01, Dim2, j, m > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim2, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_1_1< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim2, Dim23, Dim23, i, m, k, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim01, Dim2, m, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim2, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_1_1< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim2, Dim23, Dim23, i, m, k, l > operator* (const Tensor2_Expr< B, U, Dim01, Dim2, m, j > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim1, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_0_0< A, B, T, U, Dim01, Dim23, Dim1, i, j, k, l, m >, typename promote< T, U >::V, Dim1, Dim01, Dim23, Dim23, m, j, k, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim01, Dim1, i, m > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim1, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_0_0< A, B, T, U, Dim01, Dim23, Dim1, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim01, Dim23, Dim1, m, j, k, l > operator* (const Tensor2_Expr< B, U, Dim01, Dim1, i, m > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim1, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_0_1< A, B, T, U, Dim01, Dim23, Dim1, i, j, k, l, m >, typename promote< T, U >::V, Dim1, Dim01, Dim23, Dim23, m, j, k, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim01, Dim1, m, i > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim1, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Ddg_times_Tensor2_0_1< A, B, T, U, Dim01, Dim23, Dim1, i, j, k, l, m >, typename promote< T, U >::V, Dim1, Dim01, Dim23, Dim23, m, j, k, l > operator* (const Tensor2_Expr< B, U, Dim01, Dim1, m, i > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_Expr< const Ddg_times_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, k > operator* (const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_Expr< const Ddg_times_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, k > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, l > &b, const Ddg_Expr< A, T, Dim, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim23, k, l > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim23, k, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, i, j > operator* (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim23, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Ddg_times_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l >, typename promote< T, U >::V, Dim01, i, j > operator* (const Tensor2_symmetric_Expr< B, U, Dim23, k, l > &b, const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class T , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const minus_Ddg< A, T, Dim01, Dim23, i, j, k, l >, T, Dim01, Dim23, i, j, k, l > operator- (const Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor3_antisymmetric_Expr< const Dg_and_Dg_12< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, i, j, k > operator && (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor3_antisymmetric_Expr< const Dg_and_Dg_02< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, j, i, k > operator && (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_and_Tensor1< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator & (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor1_Expr< B, U, Dim2, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_and_Tensor1< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator & (const Tensor1_Expr< B, U, Dim2, k > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_and_Tensor2_symmetric< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator & (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_and_Tensor2_symmetric< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator & (const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_divide_generic< A, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator/ (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const U &d0)
 
template<class A , class B , class U , int Dim01, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3dg_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim01, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3dg_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim01, int Dim2, char i, char j, char k, int Current_Dim2>
void T3dg_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim01, int Dim2, char i, char j, char k>
void T3dg_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim01, int Dim2, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3dg_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim01 > &, const Number< Dim2 > &)
 
template<class A , class U , int Dim01, int Dim2, int Current_Dim1, int Current_Dim2>
void T3dg_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim01 > &, const Number< Dim2 > &)
 
template<class A , class U , int Dim01, int Dim2, int Current_Dim2>
void T3dg_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Dim01 > &, const Number< Dim2 > &)
 
template<class A , class U , int Dim01, int Dim2>
void T3dg_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Dim01 > &, const Number< Dim2 > &)
 
template<class A , class B , class U , int Dim12, int Dim0, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3ch_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim12, Dim0, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim12, int Dim0, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3ch_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim12, Dim0, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim12, int Dim0, char i, char j, char k, int Current_Dim2>
void T3ch_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim12, Dim0, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim12, int Dim0, char i, char j, char k>
void T3ch_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim12, Dim0, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim12, int Dim0, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3ch_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim12 > &, const Number< Dim0 > &)
 
template<class A , class U , int Dim12, int Dim0, int Current_Dim1, int Current_Dim2>
void T3ch_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim12 > &, const Number< Dim0 > &)
 
template<class A , class U , int Dim12, int Dim0, int Current_Dim2>
void T3ch_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Dim12 > &, const Number< Dim0 > &)
 
template<class A , class U , int Dim12, int Dim0>
void T3ch_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Dim12 > &, const Number< Dim0 > &)
 
template<class A , class B , class U , int Dim23, int Dim1, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2, int N>
void T4ddgrhs0_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim23, Dim1, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim23, int Dim1, char i, char j, char k, int Current_Dim1, int Current_Dim2, int N>
void T4ddgrhs0_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim23, Dim1, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim23, int Dim1, char i, char j, char k, int Current_Dim2, int N>
void T4ddgrhs0_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim23, Dim1, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim23, int Dim1, char i, char j, char k, int N>
void T4ddgrhs0_equals_T3dg (A &iter, const Dg_Expr< B, U, Dim23, Dim1, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< N > &)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_minus_Dg< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator- (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor3_Expr< const Dg_minus_Dg_02< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, Dim, i, j, k > operator- (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Dg_Expr< const Dg_or_Dg_12< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, j, k, i > operator|| (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Dg_Expr< const Dg_or_Dg_02< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, j, k, i > operator|| (const Dg_Expr< A, T, Dim, Dim, j, i, k > &a, const Dg_Expr< B, U, Dim, Dim, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_plus_Dg< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator+ (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim01, Dim2, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_plus_Dg_10< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator+ (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim01, Dim2, j, i, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor3_Expr< const Dg_plus_Dg_210< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, Dim, i, j, k > operator+ (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor2_Expr< const Dg_times_Dg_12_01< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, l > operator* (const Dg_Expr< A, T, Dim01, Dim01, i, j, k > &a, const Dg_Expr< B, U, Dim01, Dim2, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor2_Expr< const Dg_times_Dg_12_01< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, l > operator* (const Dg_Expr< B, U, Dim01, Dim2, j, k, l > &b, const Dg_Expr< A, T, Dim01, Dim01, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor2_Expr< const Dg_times_Dg_12_20< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim2, Dim01, k, l, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor2_Expr< const Dg_times_Dg_12_20< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, l > operator* (const Dg_Expr< B, U, Dim2, Dim01, k, l, j > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim23, int Dim2, char i, char j, char k, char l, char m>
const Ddg_Expr< const Dg_times_Dg_2< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m >, typename promote< T, U >::V, Dim01, Dim23, i, j, l, m > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim23, Dim2, l, m, k > &b)
 
template<class A , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_times_generic< A, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const U &d0)
 
template<class A , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const Dg_times_generic< A, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j, k > operator* (const U &d0, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor2_symmetric_Expr< const Dg_times_Tensor1_2< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i, j > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor1_Expr< B, U, Dim2, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor2_symmetric_Expr< const Dg_times_Tensor1_2< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i, j > operator* (const Tensor1_Expr< B, U, Dim2, k > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Dg_times_Tensor1_1< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, k, j > &a, const Tensor1_Expr< B, U, Dim01, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Dg_times_Tensor1_1< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j > operator* (const Tensor1_Expr< B, U, Dim01, k > &b, const Dg_Expr< A, T, Dim01, Dim2, i, k, j > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Dg_times_Tensor1_0< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j > operator* (const Dg_Expr< A, T, Dim01, Dim2, k, i, j > &a, const Tensor1_Expr< B, U, Dim01, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Dg_times_Tensor1_0< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, Dim2, i, j > operator* (const Tensor1_Expr< B, U, Dim01, k > &b, const Dg_Expr< A, T, Dim01, Dim2, k, i, j > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_0< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim3, i, j, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_0< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim3, i, j, l > operator* (const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_1< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim3, i, j, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim3, Dim2, l, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_1< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim3, i, j, l > operator* (const Tensor2_Expr< B, U, Dim3, Dim2, l, k > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_1_0< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim3, i, k, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim01, Dim3, j, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_1_0< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim3, i, k, l > operator* (const Tensor2_Expr< B, U, Dim01, Dim3, j, l > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_1_1< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim3, i, k, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim3, Dim01, l, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_1_1< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim3, i, k, l > operator* (const Tensor2_Expr< B, U, Dim3, Dim01, l, j > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_12< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim01, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_12< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Tensor2_Expr< B, U, Dim01, Dim2, j, k > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_21< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim2, Dim01, k, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_21< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Tensor2_Expr< B, U, Dim2, Dim01, k, j > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_02< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, j, i, k > &a, const Tensor2_Expr< B, U, Dim01, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_02< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Tensor2_Expr< B, U, Dim01, Dim2, j, k > &b, const Dg_Expr< A, T, Dim01, Dim2, j, i, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_20< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, k, i, j > &a, const Tensor2_Expr< B, U, Dim2, Dim01, j, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_20< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim01, i > operator* (const Tensor2_Expr< B, U, Dim2, Dim01, j, k > &b, const Dg_Expr< A, T, Dim01, Dim2, k, i, j > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_01< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a, const Tensor2_Expr< B, U, Dim01, Dim01, j, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_01< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor2_Expr< B, U, Dim01, Dim01, j, k > &b, const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_10< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a, const Tensor2_Expr< B, U, Dim01, Dim01, k, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_10< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor2_Expr< B, U, Dim01, Dim01, k, j > &b, const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_symmetric_0< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, j, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim2, k, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_symmetric_0< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, j, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim2, k, l > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_symmetric_1< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, j, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim2, l, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Dg_Expr< const Dg_times_Tensor2_symmetric_1< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, i, j, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim2, l, k > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_symmetric_1_0< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim01, i, k, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim01, j, l > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_symmetric_1_0< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim01, i, k, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim01, j, l > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_symmetric_1_1< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim01, i, k, l > operator* (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim01, l, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k, char l>
const Tensor3_Expr< const Dg_times_Tensor2_symmetric_1_1< A, B, T, U, Dim01, Dim2, i, j, k, l >, typename promote< T, U >::V, Dim01, Dim2, Dim01, i, k, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim01, l, j > &b, const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_12< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_12< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b, const Dg_Expr< A, T, Dim, Dim, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_21< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Dg_Expr< A, T, Dim, Dim, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_21< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, k, j > &b, const Dg_Expr< A, T, Dim, Dim, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_02< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Dg_Expr< A, T, Dim, Dim, j, i, k > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_02< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b, const Dg_Expr< A, T, Dim, Dim, j, i, k > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_20< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Dg_Expr< A, T, Dim, Dim, k, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_20< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b, const Dg_Expr< A, T, Dim, Dim, k, i, j > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a, const Tensor2_symmetric_Expr< B, U, Dim01, j, k > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim01, j, k > &b, const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_10< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a, const Tensor2_symmetric_Expr< B, U, Dim01, k, j > &b)
 
template<class A , class B , class T , class U , int Dim01, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Dg_times_Tensor2_symmetric_10< A, B, T, U, Dim01, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim01, k, j > &b, const Dg_Expr< A, T, Dim01, Dim2, j, k, i > &a)
 
template<class A , class T , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const minus_Dg< A, T, Dim01, Dim2, i, j, k >, T, Dim01, Dim2, i, j, k > operator- (const Dg_Expr< A, T, Dim01, Dim2, i, j, k > &a)
 
template<class T = int, char i, char j, int Dim0, int Dim1>
constexpr std::enable_if<(Dim0<=2 &&Dim1<=2), Tensor2_Expr< Levi_Civita< T >, T, Dim0, Dim1, i, j > >::type levi_civita (const Index< i, Dim0 > &, const Index< j, Dim1 > &)
 
template<class T = int, char i, char j, char k, int Dim0, int Dim1, int Dim2>
constexpr std::enable_if<(Dim0<=3 &&Dim1<=3 &&Dim2<=3), Tensor3_Expr< Levi_Civita< T >, T, Dim0, Dim1, Dim2, i, j, k > >::type levi_civita (const Index< i, Dim0 > &, const Index< j, Dim1 > &, const Index< k, Dim2 > &)
 
template<class T = int, char i, char j, char k, char l, int Dim0, int Dim1, int Dim2, int Dim3>
constexpr std::enable_if<(Dim0<=4 &&Dim1<=4 &&Dim2<=4 &&Dim3<=4), Tensor4_Expr< Levi_Civita< T >, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > >::type levi_civita (const Index< i, Dim0 > &, const Index< j, Dim1 > &, const Index< k, Dim2 > &, const Index< l, Dim3 > &)
 
 DECLARE_PROMOTE (int, double, double)
 
 DECLARE_PROMOTE (double, int, double)
 
 DECLARE_PROMOTE (int, std::complex< double >, std::complex< double >)
 
 DECLARE_PROMOTE (std::complex< double >, int, std::complex< double >)
 
 DECLARE_PROMOTE (double, std::complex< double >, std::complex< double >)
 
 DECLARE_PROMOTE (std::complex< double >, double, std::complex< double >)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Riemann_minus_Riemann< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator- (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Riemann_Expr< B, U, Dim, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Riemann_plus_Riemann< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator+ (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Riemann_Expr< B, U, Dim, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const promote< T, U >::V operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const promote< T, U >::V operator* (const Ddg_Expr< B, U, Dim, Dim, i, j, k, l > &b, const Riemann_Expr< A, T, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const promote< T, U >::V operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Ddg_Expr< B, U, Dim, Dim, i, k, j, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const promote< T, U >::V operator* (const Ddg_Expr< B, U, Dim, Dim, i, j, k, l > &b, const Riemann_Expr< A, T, Dim, i, k, j, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_0< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, j, k, l > operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_0< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, j, k, l > operator* (const Tensor1_Expr< B, U, Dim, i > &b, const Riemann_Expr< A, T, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_1< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, k, l > operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_1< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, k, l > operator* (const Tensor1_Expr< B, U, Dim, j > &b, const Riemann_Expr< A, T, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_2< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, j, l > operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_2< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, j, l > operator* (const Tensor1_Expr< B, U, Dim, k > &b, const Riemann_Expr< A, T, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_3< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, j, k > operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim, l > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor3_antisymmetric_Expr< const Riemann_times_Tensor1_3< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, Dim, i, j, k > operator* (const Tensor1_Expr< B, U, Dim, l > &b, const Riemann_Expr< A, T, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Riemann_times_Tensor2_symmetric_0< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, j, l > operator* (const Riemann_Expr< A, T, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Tensor2_symmetric_Expr< const Riemann_times_Tensor2_symmetric_0< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, j, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim, i, k > &b, const Riemann_Expr< A, T, Dim, i, j, k, l > &a)
 
template<class A , class B , char i, char j, char k, char l>
double operator* (const Riemann_Expr< A, i, j, k, l > &a, const Tensor4_Expr< B, i, j, k, l > &b)
 
template<class A , class B , char i, char j, char k, char l>
double operator* (const Tensor4_Expr< B, i, j, k, l > &b, const Riemann_Expr< A, i, j, k, l > &a)
 
template<class T , int Dim, char i>
const Tensor1_Expr< const d_boundary_Tensor0< T, Dim, i >, typename promote< T, double >::V, Dim, i > d_boundary (const Tensor0< T *> &a, const Index< i, Dim > index, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz, const Tensor2< bool, Dim, 2 > &boundary)
 
template<class T >
const promote< T, double >::V d_one_sided (const Tensor0< T *> &a, const Number< 0 > n1, const int &di, const int &dj, const int &dk, const double &dx, const double &dy, const double &dz)
 
template<class T >
const promote< T, double >::V d_one_sided (const Tensor0< T *> &a, const Number< 1 > n1, const int &di, const int &dj, const int &dk, const double &dx, const double &dy, const double &dz)
 
template<class T >
const promote< T, double >::V d_one_sided (const Tensor0< T *> &a, const Number< 2 > n1, const int &di, const int &dj, const int &dk, const double &dx, const double &dy, const double &dz)
 
template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const dd_boundary_Tensor0< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > dd_boundary (const Tensor0< T *> &a, const Index< i, Dim > index3, const Index< j, Dim > index4, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz, const Tensor2< bool, Dim, 2 > &boundary)
 
template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const ddTensor0< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > dd (const Tensor0< T *> &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
 
template<class T >
const promote< T, double >::V diffusion (const Tensor0< T *> &a, const int &di, const int &dj, const int &dk, const double &dx)
 
template<class T , int Dim, char i>
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)
 
template<class T >
const promote< T, double >::V interpolate (const Tensor0< T *> &a, const int &di, const int &dj, const int &dk, const int &i0, const int &j0, const int &k0, const double distance[3], const double conjugate[3])
 
template<class T , int Dim, char i, int axis>
const Tensor1_Expr< const d_one_sided_Tensor1< T, Dim, i, axis >, typename promote< T, double >::V, Dim, i > d_one_sided (const Tensor1< T *, Dim > &a, const Number< axis > n1, const Index< i, Dim > index1, const int &di, const int &dj, const int &dk, const double &dx, const double &dy, const double &dz)
 
template<class T , int Dim0, int Dim12, char i, char j, char k>
const Dg_Expr< const ddTensor1< T, Dim0, Dim12, i, j, k >, typename promote< T, double >::V, Dim0, Dim12, i, j, k > dd (const Tensor1< T *, Dim0 > &a, const Index< k, Dim0 > index0, const Index< i, Dim12 > index1, const Index< j, Dim12 > index2, const Tensor1< int, Dim12 > &d_ijk, const Tensor1< double, Dim12 > &d_xyz)
 
template<class T , int Dim, char i>
const Tensor1_Expr< const diffusion_Tensor1< T, Dim, i >, typename promote< T, double >::V, Dim, i > diffusion (const Tensor1< T *, Dim > &a, const Index< i, Dim > index1, const int &di, const int &dj, const int &dk, const double &dx)
 
template<class T , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const dTensor1< T, Dim0, Dim1, i, j >, typename promote< T, double >::V, Dim0, Dim1, i, j > d (const Tensor1< T *, Dim0 > &a, const Index< i, Dim0 > index1, const Index< j, Dim1 > index2, const Tensor1< int, Dim1 > &d_ijk, const Tensor1< double, Dim1 > &d_xyz)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const generic_minus_Tensor1< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator- (const U &d0, const Tensor1_Expr< A, T, Dim, i > &a)
 
template<class T , int Dim, char i>
const Tensor1_Expr< const interpolate_Tensor1< T, Dim, i >, typename promote< T, double >::V, Dim, i > interpolate (const Tensor1< T *, Dim > &a, const Index< i, Dim > index1, const int &di, const int &dj, const int &dk, const int &i0, const int &j0, const int &k0, const double distance[3], const double conjugate[3])
 
template<class A , class T , int Dim, char i>
const Tensor1_Expr< const minus_Tensor1< A, T, Dim, i >, T, Dim, i > operator- (const Tensor1_Expr< A, T, Dim, i > &a)
 
template<class A , class B , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_and_Tensor1< A, B, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator & (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor1_carat_Tensor1< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator^ (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, j > &b)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_divide_generic< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator/ (const Tensor1_Expr< A, T, Dim, i > &a, const U &d0)
 
template<class A , class B , class U , int Dim, char i, int Current_Dim>
void T1_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i>
void T1_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, int Current_Dim>
void T1_equals_addolc_left_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i>
void T1_equals_addolc_left_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, int Current_Dim>
void T1_equals_addolc_right_T1 (A &iter, Tensor1_Expr< B, U, Dim, i > result, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i>
void T1_equals_addolc_right_T1 (A &iter, Tensor1_Expr< B, U, Dim, i > result, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, int Current_Dim>
void T1_plus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i>
void T1_plus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, int Current_Dim>
void T1_minus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i>
void T1_minus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > result, const Number< 1 > &)
 
template<class A , class U , int Current_Dim>
void T1_equals_generic (A &iter, const U &u, const Number< Current_Dim > &)
 
template<class A , class U >
void T1_equals_generic (A &iter, const U &u, const Number< 1 > &)
 
template<class A , class U , int Current_Dim>
void T1_plus_equals_generic (A &iter, const U &u, const Number< Current_Dim > &)
 
template<class A , class U >
void T1_plus_equals_generic (A &iter, const U &u, const Number< 1 > &)
 
template<class A , class U , int Current_Dim>
void T1_minus_equals_generic (A &iter, const U &u, const Number< Current_Dim > &)
 
template<class A , class U >
void T1_minus_equals_generic (A &iter, const U &u, const Number< 1 > &)
 
template<class A , class U , int Current_Dim>
void T1_times_equals_generic (A &iter, const U &u, const Number< Current_Dim > &)
 
template<class A , class U >
void T1_times_equals_generic (A &iter, const U &u, const Number< 1 > &)
 
template<class A , class U , int Current_Dim>
void T1_divide_equals_generic (A &iter, const U &u, const Number< Current_Dim > &)
 
template<class A , class U >
void T1_divide_equals_generic (A &iter, const U &u, const Number< 1 > &)
 
template<class A , class B , class U , int Dim1, char i, int N, int Current_Dim>
void T2rhs0_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim1, char i, int N>
void T2rhs0_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim1, char i, int N, int Current_Dim>
void T2rhs0_plus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim1, char i, int N>
void T2rhs0_plus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim1, char i, int N, int Current_Dim>
void T2rhs0_minus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim1, char i, int N>
void T2rhs0_minus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs0_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs0_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs0_plus_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs0_plus_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs0_minus_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs0_minus_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs0_times_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs0_times_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs0_divide_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs0_divide_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim1, char i, int N, int Current_Dim>
void T2rhs1_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim1, char i, int N>
void T2rhs1_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim1, char i, int N, int Current_Dim>
void T2rhs1_plus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim1, char i, int N>
void T2rhs1_plus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim1, char i, int N, int Current_Dim>
void T2rhs1_minus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim1, char i, int N>
void T2rhs1_minus_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim1, i > &result, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs1_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs1_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs1_plus_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs1_plus_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs1_minus_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs1_minus_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs1_times_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs1_times_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class U , int N, int Current_Dim>
void T2rhs1_divide_equals_generic (A &iter, const U &u, const Number< N > &N1, const Number< Current_Dim > &)
 
template<class A , class U , int N>
void T2rhs1_divide_equals_generic (A &iter, const U &u, const Number< N > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, int N1, int N2, int Current_Dim>
void T3dgrhs12_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > &result, const Number< N1 > &NN1, const Number< N2 > &NN2, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i, int N1, int N2>
void T3dgrhs12_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > &result, const Number< N1 > &, const Number< N2 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, int N1, int N2, int Current_Dim>
void T3dgrhs01_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > &result, const Number< N1 > &NN1, const Number< N2 > &NN2, const Number< Current_Dim > &)
 
template<class A , class B , class U , int Dim, char i, int N1, int N2>
void T3dgrhs01_equals_T1 (A &iter, const Tensor1_Expr< B, U, Dim, i > &result, const Number< N1 > &, const Number< N2 > &, const Number< 1 > &)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_minus_generic< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator- (const Tensor1_Expr< A, T, Dim, i > &a, const U &d0)
 
template<class A , class B , class T , class U , char i, int Dim>
const Tensor1_Expr< const Tensor1_minus_Tensor1< A, B, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator- (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor1_or_Tensor1< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator|| (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, j > &b)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_plus_generic< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator+ (const Tensor1_Expr< A, T, Dim, i > &a, const U &d0)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_plus_generic< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator+ (const U &d0, const Tensor1_Expr< A, T, Dim, i > &a)
 
template<class A , class B , class T , class U , char i, int Dim>
const Tensor1_Expr< const Tensor1_plus_Tensor1< A, B, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator+ (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, i > &b)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_times_generic< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator* (const Tensor1_Expr< A, T, Dim, i > &a, const U &d0)
 
template<class A , class T , class U , int Dim, char i>
const Tensor1_Expr< const Tensor1_times_generic< A, T, U, Dim, i >, typename promote< T, U >::V, Dim, i > operator* (const U &d0, const Tensor1_Expr< A, T, Dim, i > &a)
 
template<class A , class B , class T , class U , int Dim, char i, int Current_Dim>
const promote< T, U >::V T1_times_T1 (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, i > &b, const Number< Current_Dim > &)
 
template<class A , class B , class T , class U , int Dim, char i>
const promote< T, U >::V T1_times_T1 (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, i > &b, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, char i>
const promote< T, U >::V operator* (const Tensor1_Expr< A, T, Dim, i > &a, const Tensor1_Expr< B, U, Dim, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor1_times_Tensor1< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor1_Expr< A, T, Dim0, i > &a, const Tensor1_Expr< B, U, Dim1, j > &b)
 
template<class A , class T , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const conj_Tensor2< A, T, Dim0, Dim1, i, j >, T, Dim0, Dim1, i, j > conj (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class T , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const minus_Tensor2< A, T, Dim0, Dim1, i, j >, T, Dim0, Dim1, i, j > operator- (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_and_Tensor1_0< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator & (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor1_Expr< B, U, Dim0, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_and_Tensor1_0< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator & (const Tensor1_Expr< B, U, Dim0, i > &b, const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_and_Tensor1_1< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator & (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor1_Expr< B, U, Dim1, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_and_Tensor1_1< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator & (const Tensor1_Expr< B, U, Dim1, j > &b, const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_carat_Tensor2_10< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< A, T, Dim, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim1, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_carat_Tensor2_11< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< A, T, Dim, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim1, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_carat_Tensor2_00< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< A, T, Dim1, Dim, j, i > &a, const Tensor2_Expr< B, U, Dim1, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_carat_Tensor2_01< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< A, T, Dim1, Dim, j, i > &a, const Tensor2_Expr< B, U, Dim, Dim1, k, j > &b)
 
template<class A , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_divide_generic< A, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator/ (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const U &d0)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_equals_adolc_left_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_equals_adolc_left_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_equals_adolc_left_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_equals_adolc_rigth_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_equals_adolc_rigth_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_equals_adolc_rigth_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_plus_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_plus_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_plus_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_minus_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_minus_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_minus_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_plus_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_plus_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_plus_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
void T2_minus_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
void T2_minus_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j>
void T2_minus_equals_switched_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim0, int Current_Dim1, Layout layout>
void T2_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim1, Layout layout>
void T2_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, Layout layout>
void T2_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim0, int Current_Dim1, Layout layout>
void T2_plus_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim1, Layout layout>
void T2_plus_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, Layout layout>
void T2_plus_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim0, int Current_Dim1, Layout layout>
void T2_minus_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim1, Layout layout>
void T2_minus_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, Layout layout>
void T2_minus_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim0, int Current_Dim1, Layout layout>
void T2_times_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim1, Layout layout>
void T2_times_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, Layout layout>
void T2_times_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim0, int Current_Dim1, Layout layout>
void T2_divide_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Current_Dim1, Layout layout>
void T2_divide_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Dim0, int Dim1, Layout layout>
void T2_divide_equals_generic (Tensor2< A, Dim0, Dim1, layout > &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int N, int Current_Dim0, int Current_Dim1>
void T3dgrhs0_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int N, int Current_Dim1>
void T3dgrhs0_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim0, int Dim1, char i, char j, int N>
void T3dgrhs0_equals_T2 (A &iter, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &result, const Number< 1 > &, const Number< 1 > &, const Number< N > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_minus_Tensor2_01< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator- (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_minus_Tensor2_10< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator- (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_or_Tensor2< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator|| (const Tensor2_Expr< A, T, Dim, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_or_Tensor2_switched< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator|| (const Tensor2_Expr< A, T, Dim, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_plus_Tensor2_01< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator+ (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_plus_Tensor2_10< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator+ (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &b)
 
template<class A , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_times_generic< A, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const U &d0)
 
template<class A , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const Tensor2_times_generic< A, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const U &d0, const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor1_Expr< const Tensor2_times_Tensor1_1< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor1_Expr< B, U, Dim1, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor1_Expr< const Tensor2_times_Tensor1_0< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor2_Expr< A, T, Dim1, Dim0, j, i > &a, const Tensor1_Expr< B, U, Dim1, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor1_Expr< const Tensor2_times_Tensor1_1< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor1_Expr< B, U, Dim1, j > &b, const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const Tensor1_Expr< const Tensor2_times_Tensor1_0< A, B, T, U, Dim0, Dim1, i, j >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor1_Expr< B, U, Dim1, j > &b, const Tensor2_Expr< A, T, Dim1, Dim0, j, i > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor2_times_Tensor1< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor1_Expr< B, U, Dim2, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor2_times_Tensor1< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator* (const Tensor1_Expr< B, U, Dim2, k > &b, const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
const promote< T, U >::V T2_times_T2 (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
const promote< T, U >::V T2_times_T2 (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const promote< T, U >::V T2_times_T2 (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const promote< T, U >::V operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j, int Current_Dim0, int Current_Dim1>
const promote< T, U >::V T2_times_switched_T2 (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j, int Current_Dim1>
const promote< T, U >::V T2_times_switched_T2 (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &b, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const promote< T, U >::V T2_times_switched_T2 (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim0, Dim1, j, i > &b, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j>
const promote< T, U >::V operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim1, Dim0, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor2_times_Tensor2_10< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim1, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor2_times_Tensor2_11< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim2, Dim1, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor2_times_Tensor2_00< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor2_Expr< A, T, Dim1, Dim0, j, i > &a, const Tensor2_Expr< B, U, Dim1, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor2_times_Tensor2_01< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor2_Expr< A, T, Dim1, Dim0, j, i > &a, const Tensor2_Expr< B, U, Dim2, Dim1, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor2_times_Tensor2< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator* (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b)
 
template<class A , class B , class T , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr< const transform_Tensor2< A, B, T, Dim0, Dim1, i, j >, T, Dim0, Dim1, i, j > transform (const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &a, B function)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, FTensor::Layout layout>
std::ostream & Tensor2_ostream_row (std::ostream &os, const FTensor::Tensor2< T, Tensor_Dim0, Tensor_Dim1, layout > &t, const int &i)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, FTensor::Layout layout>
std::istream & Tensor2_istream_row (std::istream &is, FTensor::Tensor2< T, Tensor_Dim0, Tensor_Dim1, layout > &t, const int &i)
 
template<class T , int Tensor_Dim>
std::ostream & Tensor2_antisymmetric_ostream_row (std::ostream &os, const FTensor::Tensor2_antisymmetric< T, Tensor_Dim > &t, const int &i)
 
template<class T , int Tensor_Dim>
std::istream & Tensor2_antisymmetric_istream_row (std::istream &is, FTensor::Tensor2_antisymmetric< T, Tensor_Dim > &t, const int &i)
 
template<class T , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const d_boundary_Tensor2_symmetric< T, Dim01, Dim2, i, j, k >, typename promote< T, double >::V, Dim01, Dim2, i, j, k > d_boundary (const Tensor2_symmetric< T *, Dim01 > &a, const Index< i, Dim01 > index1, const Index< j, Dim01 > index2, const Index< k, Dim2 > index3, const Tensor1< int, Dim2 > &d_ijk, const Tensor1< double, Dim2 > &d_xyz, const Tensor2< bool, Dim2, 2 > &boundary)
 
template<class T , int Dim, char i, char j, int axis>
const Tensor2_symmetric_Expr< const d_one_sided_Tensor2_symmetric< T, Dim, i, j, axis >, typename promote< T, double >::V, Dim, i, j > d_one_sided (const Tensor2_symmetric< T *, Dim > &a, const Number< axis > n1, const Index< i, Dim > index1, const Index< j, Dim > index2, const int &di, const int &dj, const int &dk, const double &dx, const double &dy, const double &dz)
 
template<class T , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const dd_boundary_Tensor2_symmetric< T, Dim01, Dim23, i, j, k, l >, typename promote< T, double >::V, Dim01, Dim23, i, j, k, l > dd_boundary (const Tensor2_symmetric< T *, Dim01 > &a, const Index< i, Dim01 > index1, const Index< j, Dim01 > index2, const Index< k, Dim23 > index3, const Index< l, Dim23 > index4, const Tensor1< int, Dim23 > &d_ijk, const Tensor1< double, Dim23 > &d_xyz, const Tensor2< bool, Dim23, 2 > &boundary)
 
template<class T , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr< const ddTensor2_symmetric< T, Dim01, Dim23, i, j, k, l >, typename promote< T, double >::V, Dim01, Dim23, i, j, k, l > dd (const Tensor2_symmetric< T *, Dim01 > &a, const Index< i, Dim01 > index1, const Index< j, Dim01 > index2, const Index< k, Dim23 > index3, const Index< l, Dim23 > index4, const Tensor1< int, Dim23 > &d_ijk, const Tensor1< double, Dim23 > &d_xyz)
 
template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const diffusion_Tensor2_symmetric< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > diffusion (const Tensor2_symmetric< T *, Dim > &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const int &di, const int &dj, const int &dk, const double &dx)
 
template<class T , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr< const dTensor2_symmetric< T, Dim01, Dim2, i, j, k >, typename promote< T, double >::V, Dim01, Dim2, i, j, k > d (const Tensor2_symmetric< T *, Dim01 > &a, const Index< i, Dim01 > index1, const Index< j, Dim01 > index2, const Index< k, Dim2 > index3, const Tensor1< int, Dim2 > &d_ijk, const Tensor1< double, Dim2 > &d_xyz)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const generic_minus_Tensor2_symmetric< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator- (const U &d0, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const interpolate_Tensor2_symmetric< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > interpolate (const Tensor2_symmetric< T *, Dim > &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const int &di, const int &dj, const int &dk, const int &i0, const int &j0, const int &k0, const double distance[3], const double conjugate[3])
 
template<class A , class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const minus_Tensor2_symmetric< A, T, Dim, i, j >, T, Dim, i, j > operator- (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_and_Tensor2_symmetric_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator & (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_and_Tensor2_symmetric_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator & (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_10< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_10< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< B, U, Dim, Dim, j, k > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_11< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_11< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< B, U, Dim, Dim, k, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_00< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor2_Expr< B, U, Dim, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_00< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< B, U, Dim, Dim, j, k > &b, const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_01< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor2_Expr< B, U, Dim, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_carat_Tensor2_01< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, i, k > operator^ (const Tensor2_Expr< B, U, Dim, Dim, k, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_divide_generic< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator/ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const U &d0)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
void T2s_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim1>
void T2s_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j>
void T2s_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
void T2s_equals_adolc_left_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim1>
void T2s_equals_adolc_left_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j>
void T2s_equals_adolc_left_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
void T2s_plus_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim1>
void T2s_plus_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j>
void T2s_plus_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
void T2s_minus_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim1>
void T2s_minus_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j>
void T2s_minus_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
void T2s_and_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j, int Current_Dim1>
void T2s_and_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class U , int Dim, char i, char j>
void T2s_and_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &result, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Current_Dim0, int Current_Dim1>
void T2s_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Current_Dim1>
void T2s_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U >
void T2s_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Current_Dim0, int Current_Dim1>
void T2s_plus_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Current_Dim1>
void T2s_plus_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U >
void T2s_plus_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Current_Dim0, int Current_Dim1>
void T2s_minus_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Current_Dim1>
void T2s_minus_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U >
void T2s_minus_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Current_Dim0, int Current_Dim1>
void T2s_times_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Current_Dim1>
void T2s_times_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U >
void T2s_times_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Current_Dim0, int Current_Dim1>
void T2s_divide_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class U , int Current_Dim1>
void T2s_divide_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class U >
void T2s_divide_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim01, char i, char j, int N, int Current_Dim0, int Current_Dim1>
void T3dgrhs2_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim01, char i, char j, int N, int Current_Dim1>
void T3dgrhs2_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim01, char i, char j, int N>
void T3dgrhs2_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &result, const Number< 1 > &, const Number< 1 > &, const Number< N > &)
 
template<class A , class B , class U , int Dim01, char i, char j, int N0, int N1, int Current_Dim0, int Current_Dim1>
void T4ddgrhs01_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< N0 > &, const Number< N1 > &)
 
template<class A , class B , class U , int Dim01, char i, char j, int N0, int N1, int Current_Dim1>
void T4ddgrhs01_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< N0 > &, const Number< N1 > &)
 
template<class A , class B , class U , int Dim01, char i, char j, int N0, int N1>
void T4ddgrhs01_equals_T2s (A &iter, const Tensor2_symmetric_Expr< B, U, Dim01, i, j > &result, const Number< 1 > &, const Number< 1 > &, const Number< N0 > &, const Number< N1 > &)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_minus_generic< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator- (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const U &d0)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_symmetric_minus_Tensor2_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator- (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_minus_Tensor2_symmetric_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator- (const Tensor2_Expr< B, U, Dim, Dim, i, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_symmetric_minus_Tensor2_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator- (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_minus_Tensor2_symmetric_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator- (const Tensor2_Expr< B, U, Dim, Dim, j, i > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_minus_Tensor2_symmetric_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator- (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_minus_Tensor2_symmetric_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator- (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_mod_Tensor2_symmetric_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator% (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_mod_Tensor2_symmetric_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator% (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_plus_generic< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator+ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const U &d0)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_plus_generic< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator+ (const U &d0, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_symmetric_plus_Tensor2_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator+ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_symmetric_plus_Tensor2_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator+ (const Tensor2_Expr< B, U, Dim, Dim, i, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_symmetric_plus_Tensor2_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator+ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_Expr< const Tensor2_symmetric_plus_Tensor2_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, Dim, i, j > operator+ (const Tensor2_Expr< B, U, Dim, Dim, j, i > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_plus_Tensor2_symmetric_01< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator+ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_plus_Tensor2_symmetric_10< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator+ (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_times_generic< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const U &d0)
 
template<class A , class T , class U , int Dim, char i, char j>
const Tensor2_symmetric_Expr< const Tensor2_symmetric_times_generic< A, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i, j > operator* (const U &d0, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor1_Expr< const Tensor2_symmetric_times_Tensor1_1< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor1_Expr< B, U, Dim, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor1_Expr< const Tensor2_symmetric_times_Tensor1_0< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i > operator* (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor1_Expr< B, U, Dim, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor1_Expr< const Tensor2_symmetric_times_Tensor1_1< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i > operator* (const Tensor1_Expr< B, U, Dim, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const Tensor1_Expr< const Tensor2_symmetric_times_Tensor1_0< A, B, T, U, Dim, i, j >, typename promote< T, U >::V, Dim, i > operator* (const Tensor1_Expr< B, U, Dim, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k>
const Dg_Expr< const Tensor2_symmetric_times_Tensor1< A, B, T, U, Dim, Dim2, i, j, k >, typename promote< T, U >::V, Dim, Dim2, i, j, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor1_Expr< B, U, Dim2, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k>
const Dg_Expr< const Tensor2_symmetric_times_Tensor1< A, B, T, U, Dim, Dim2, i, j, k >, typename promote< T, U >::V, Dim, Dim2, i, j, k > operator* (const Tensor1_Expr< B, U, Dim2, k > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
const promote< T, U >::V T2s_times_T2_01 (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim1>
const promote< T, U >::V T2s_times_T2_01 (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V T2s_times_T2_01 (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V operator* (const Tensor2_Expr< B, U, Dim, Dim, i, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
const promote< T, U >::V T2s_times_T2_01 (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim1>
const promote< T, U >::V T2s_times_T2_01 (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V T2s_times_T2_01 (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V operator* (const Tensor2_Expr< B, U, Dim, Dim, j, i > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_10< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim, Dim1, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_10< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_Expr< B, U, Dim, Dim1, j, k > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_11< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_Expr< B, U, Dim1, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_11< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_Expr< B, U, Dim1, Dim, k, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_00< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor2_Expr< B, U, Dim, Dim1, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_00< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_Expr< B, U, Dim, Dim1, j, k > &b, const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_01< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor2_Expr< B, U, Dim1, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_01< A, B, T, U, Dim, Dim1, i, j, k >, typename promote< T, U >::V, Dim, Dim1, i, k > operator* (const Tensor2_Expr< B, U, Dim1, Dim, k, j > &b, const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
const promote< T, U >::V T2s_times_T2s (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim1>
const promote< T, U >::V T2s_times_T2s (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V T2s_times_T2s (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim0, int Current_Dim1>
const promote< T, U >::V T2s_times_switched_T2s (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, int Current_Dim1>
const promote< T, U >::V T2s_times_switched_T2s (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b, const Number< 1 > &, const Number< Current_Dim1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V T2s_times_switched_T2s (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j>
const promote< T, U >::V operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_symmetric_10< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_symmetric_11< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_symmetric_00< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Tensor2_Expr< const Tensor2_symmetric_times_Tensor2_symmetric_01< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, i, k > operator* (const Tensor2_symmetric_Expr< A, T, Dim, j, i > &a, const Tensor2_symmetric_Expr< B, U, Dim, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, char i, char j, char k, char l>
const Ddg_Expr< const Tensor2_symmetric_times_Tensor2_symmetric< A, B, T, U, Dim0, Dim1, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j, k, l > operator* (const Tensor2_symmetric_Expr< A, T, Dim0, i, j > &a, const Tensor2_symmetric_Expr< B, U, Dim1, k, l > &b)
 
template<class T , int Tensor_Dim>
std::ostream & Tensor2_symmetric_ostream_row (std::ostream &os, const FTensor::Tensor2_symmetric< T, Tensor_Dim > &t, const int &i)
 
template<class T , int Tensor_Dim>
std::istream & Tensor2_symmetric_istream_row (std::istream &is, FTensor::Tensor2_symmetric< T, Tensor_Dim > &t, const int &i)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_T3 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3_equals_T3 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim2>
void T3_equals_T3 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
void T3_equals_T3 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_021 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_021 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim2>
void T3_equals_T3_021 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
void T3_equals_T3_021 (A &iter, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_102 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_102 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim2>
void T3_equals_T3_102 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
void T3_equals_T3_102 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_120 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_120 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim2>
void T3_equals_T3_120 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
void T3_equals_T3_120 (A &iter, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_201 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_201 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim2>
void T3_equals_T3_201 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
void T3_equals_T3_201 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_210 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim1, int Current_Dim2>
void T3_equals_T3_210 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, i, j, k > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim2>
void T3_equals_T3_210 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
void T3_equals_T3_210 (A &iter, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class U , int Dim0, int Dim1, int Dim2, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_equals_generic (A &iter, const U &u, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim0 > &, const Number< Dim1 > &, const Number< Dim2 > &)
 
template<class A , class U , int Dim0, int Dim1, int Dim2, int Current_Dim1, int Current_Dim2>
void T3_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Dim0 > &, const Number< Dim1 > &, const Number< Dim2 > &)
 
template<class A , class U , int Dim0, int Dim1, int Dim2, int Current_Dim2>
void T3_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Dim0 > &, const Number< Dim1 > &, const Number< Dim2 > &)
 
template<class A , class U , int Dim0, int Dim1, int Dim2>
void T3_equals_generic (A &iter, const U &u, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Dim0 > &, const Number< Dim1 > &, const Number< Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator- (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_minus_Tensor3_21< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator- (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_minus_Tensor3_10< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator- (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_minus_Tensor3_201< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator- (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, j, k, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_minus_Tensor3_120< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator- (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_minus_Tensor3_210< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator- (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const Dg_Expr< const Tensor3_or_Tensor3_12< A, B, T, U, Dim0, Dim12, i, j, k >, typename promote< T, U >::V, Dim0, Dim12, j, k, i > operator|| (const Tensor3_Expr< A, T, Dim0, Dim12, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim02, int Dim1, char i, char j, char k>
const Dg_Expr< const Tensor3_or_Tensor3_02< A, B, T, U, Dim02, Dim1, i, j, k >, typename promote< T, U >::V, Dim02, Dim1, i, k, j > operator|| (const Tensor3_Expr< A, T, Dim02, Dim1, Dim02, i, j, k > &a, const Tensor3_Expr< B, U, Dim02, Dim1, Dim02, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator+ (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_plus_Tensor3_21< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator+ (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_plus_Tensor3_10< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator+ (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_plus_Tensor3_201< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator+ (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, j, k, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_plus_Tensor3_120< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator+ (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_plus_Tensor3_210< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator+ (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, j, i > &b)
 
template<class T , int Dim0, int Dim1, int Dim2, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3_increment (const Tensor3< T, Dim0, Dim1, Dim2 > &iter, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class T , int Dim0, int Dim1, int Dim2, int Current_Dim1, int Current_Dim2>
void T3_increment (const Tensor3< T, Dim0, Dim1, Dim2 > &iter, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class T , int Dim0, int Dim1, int Dim2, int Current_Dim2>
void T3_increment (const Tensor3< T, Dim0, Dim1, Dim2 > &iter, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class T , int Dim0, int Dim1, int Dim2>
void T3_increment (const Tensor3< T, Dim0, Dim1, Dim2 > &iter, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_012 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, i, j, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_012 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, i, j, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3dg_012 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, i, j, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3dg_012 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, i, j, k > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_201 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, k, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_201 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, k, i, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3dg_201 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, k, i, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const promote< T, U >::V T3_times_T3dg_201 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, k, i, j > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_120 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, j, k, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_120 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, j, k, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3dg_120 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, j, k, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k>
const promote< T, U >::V T3_times_T3dg_120 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, j, k, i > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, j, k, i > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_102 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, j, i, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_102 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, j, i, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3dg_102 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, j, i, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3dg_102 (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, j, i, k > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim, Dim, Dim2, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, j, i, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_210 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, k, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_210 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, k, j, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3dg_210 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, k, j, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k>
const promote< T, U >::V T3_times_T3dg_210 (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, k, j, i > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim0, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_021 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, i, k, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3dg_021 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, i, k, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3dg_021 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, i, k, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const promote< T, U >::V T3_times_T3dg_021 (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, i, k, j > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim, int Dim1, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim1, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim2, int Dim1, int Dim01, char i, char j, char k, char l>
const Tensor2_Expr< const Tensor3_times_Dg_02_20< A, B, T, U, Dim2, Dim1, Dim01, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim01, i, l > operator* (const Tensor3_Expr< A, T, Dim2, Dim1, Dim01, j, i, k > &a, const Dg_Expr< B, U, Dim01, Dim2, k, l, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim, char i, char j, char k, char l, char m>
Tensor4_Expr< const Tensor3_times_Dg< A, B, T, U, Dim0, Dim1, Dim, Dim2, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim, Dim2, i, j, l, m > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim, i, j, k > &a, const Dg_Expr< B, U, Dim, Dim2, l, k, m > &b)
 
template<class A , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_times_generic< A, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const U &d0)
 
template<class A , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor3_Expr< const Tensor3_times_generic< A, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator* (const U &d0, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor3_times_Tensor1_1< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor1_Expr< B, U, Dim1, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor3_times_Tensor1_1< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor1_Expr< B, U, Dim1, j > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor3_times_Tensor1_0< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor1_Expr< B, U, Dim0, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor3_times_Tensor1_0< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor1_Expr< B, U, Dim0, i > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor3_times_Tensor1_2< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor1_Expr< B, U, Dim2, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor2_Expr< const Tensor3_times_Tensor1_2< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor1_Expr< B, U, Dim2, k > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_12< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim1, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_12< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor2_Expr< B, U, Dim1, Dim2, j, k > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_02< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim1, i > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, j, i, k > &a, const Tensor2_Expr< B, U, Dim0, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_02< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim1, i > operator* (const Tensor2_Expr< B, U, Dim0, Dim2, j, k > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, j, i, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_01< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, j, k, i > &a, const Tensor2_Expr< B, U, Dim0, Dim1, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_01< A, B, T, U, Dim0, Dim1, Dim2, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor2_Expr< B, U, Dim0, Dim1, j, k > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, j, k, i > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_2_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, j, l > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_2_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, j, l > operator* (const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_2_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, j, l > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor2_Expr< B, U, Dim3, Dim2, l, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_2_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, j, l > operator* (const Tensor2_Expr< B, U, Dim3, Dim2, l, k > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_1_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim2, Dim3, i, k, l > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim3, i, j, l > &a, const Tensor2_Expr< B, U, Dim1, Dim2, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_1_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim2, Dim3, i, k, l > operator* (const Tensor2_Expr< B, U, Dim1, Dim2, j, k > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim3, i, j, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_1_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim2, Dim3, i, k, l > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim3, i, j, l > &a, const Tensor2_Expr< B, U, Dim2, Dim1, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_1_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim2, Dim3, i, k, l > operator* (const Tensor2_Expr< B, U, Dim2, Dim1, k, j > &b, const Tensor3_Expr< A, T, Dim0, Dim1, Dim3, i, j, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_0_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, Dim3, j, k, l > operator* (const Tensor3_Expr< A, T, Dim0, Dim2, Dim3, i, k, l > &a, const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_0_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, Dim3, j, k, l > operator* (const Tensor2_Expr< B, U, Dim0, Dim1, i, j > &b, const Tensor3_Expr< A, T, Dim0, Dim2, Dim3, i, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_0_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, Dim3, j, k, l > operator* (const Tensor3_Expr< A, T, Dim0, Dim2, Dim3, i, k, l > &a, const Tensor2_Expr< B, U, Dim1, Dim0, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
const Tensor3_Expr< const Tensor3_times_Tensor2_0_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, Dim3, j, k, l > operator* (const Tensor2_Expr< B, U, Dim1, Dim0, j, i > &b, const Tensor3_Expr< A, T, Dim0, Dim2, Dim3, i, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_symmetric_12< A, B, T, U, Dim0, Dim, i, j, k >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_symmetric_12< A, B, T, U, Dim0, Dim, i, j, k >, typename promote< T, U >::V, Dim0, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b, const Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim1, int Dim, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_symmetric_02< A, B, T, U, Dim1, Dim, i, j, k >, typename promote< T, U >::V, Dim1, i > operator* (const Tensor3_Expr< A, T, Dim, Dim1, Dim, j, i, k > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim1, int Dim, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_symmetric_02< A, B, T, U, Dim1, Dim, i, j, k >, typename promote< T, U >::V, Dim1, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b, const Tensor3_Expr< A, T, Dim, Dim1, Dim, j, i, k > &a)
 
template<class A , class B , class T , class U , int Dim2, int Dim, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_symmetric_01< A, B, T, U, Dim2, Dim, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor3_Expr< A, T, Dim, Dim, Dim2, j, k, i > &a, const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b)
 
template<class A , class B , class T , class U , int Dim2, int Dim, char i, char j, char k>
const Tensor1_Expr< const Tensor3_times_Tensor2_symmetric_01< A, B, T, U, Dim2, Dim, i, j, k >, typename promote< T, U >::V, Dim2, i > operator* (const Tensor2_symmetric_Expr< B, U, Dim, j, k > &b, const Tensor3_Expr< A, T, Dim, Dim, Dim2, j, k, i > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3_012 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3_012 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3_012 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3_012 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3_201 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3_201 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3_201 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3_201 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3_120 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, j, k, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3_120 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, j, k, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3_120 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, j, k, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3_120 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, j, k, i > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim2, Dim0, j, k, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3_102 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3_102 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3_102 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3_102 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3_210 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, k, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3_210 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, k, j, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3_210 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, k, j, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3_210 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, k, j, i > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim2, Dim1, Dim0, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3_times_T3_021 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3_times_T3_021 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3_times_T3_021 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V T3_times_T3_021 (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim23, int Dim4, int Dim5, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor3_times_Tensor3_21< A, B, T, U, Dim0, Dim1, Dim23, Dim4, Dim5, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim4, Dim5, i, j, l, m > operator* (const Tensor3_Expr< A, T, Dim0, Dim1, Dim23, i, j, k > &a, const Tensor3_Expr< B, U, Dim23, Dim4, Dim5, k, l, m > &b)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>
std::ostream & Tensor3_ostream_row (std::ostream &os, const FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > &t, const int &i, const int &j)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>
std::ostream & Tensor3_ostream_block (std::ostream &os, const FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > &t, const int &i)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>
std::istream & Tensor3_istream_row (std::istream &is, FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > &t, const int &i, const int &j)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2>
std::istream & Tensor3_istream_block (std::istream &is, FTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > &t, const int &i)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3as_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, j, k > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
void T3as_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, j, k > &result, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
void T3as_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, j, k > &result, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k>
void T3as_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, j, k > &result, const Number< 1 > &, const Number< 1 > &, const Number< 2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
void T3as_switched_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, k, j > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
void T3as_switched_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, k, j > &result, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
void T3as_switched_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, k, j > &result, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< 2 > &)
 
template<class A , class B , class U , int Dim0, int Dim12, char i, char j, char k>
void T3as_switched_equals_T3as (A &iter, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, k, j > &result, const Number< 1 > &, const Number< 1 > &, const Number< 2 > &)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Tensor3_antisymmetric_mod_Tensor1< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator% (const Tensor3_antisymmetric_Expr< A, T, Dim, Dim, j, k, l > &a, const Tensor1_Expr< B, U, Dim, i > &b)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k, char l>
const Riemann_Expr< const Tensor3_antisymmetric_mod_Tensor1< A, B, T, U, Dim, i, j, k, l >, typename promote< T, U >::V, Dim, i, j, k, l > operator% (const Tensor1_Expr< B, U, Dim, i > &b, const Tensor3_antisymmetric_Expr< A, T, Dim, Dim, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, char i, char j, char k>
const Dg_Expr< const Tensor3_antisymmetric_or_Tensor3_antisymmetric< A, B, T, U, Dim, i, j, k >, typename promote< T, U >::V, Dim, Dim, i, k, j > operator|| (const Tensor3_antisymmetric_Expr< A, T, Dim, Dim, i, j, k > &a, const Tensor3_antisymmetric_Expr< B, U, Dim, Dim, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const Tensor3_antisymmetric_Expr< const Tensor3_antisymmetric_plus_Tensor3_antisymmetric< A, B, T, U, Dim0, Dim12, i, j, k >, typename promote< T, U >::V, Dim0, Dim12, i, j, k > operator+ (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const Tensor3_antisymmetric_Expr< const Tensor3_antisymmetric_plus_Tensor3_antisymmetric_12< A, B, T, U, Dim0, Dim12, i, j, k >, typename promote< T, U >::V, Dim0, Dim12, i, j, k > operator+ (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, k, j > &b)
 
template<class A , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const Tensor3_antisymmetric_Expr< const Tensor3_antisymmetric_times_generic< A, T, U, Dim0, Dim12, i, j, k >, typename promote< T, U >::V, Dim0, Dim12, i, j, k > operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const U &d0)
 
template<class A , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const Tensor3_antisymmetric_Expr< const Tensor3_antisymmetric_times_generic< A, T, U, Dim0, Dim12, i, j, k >, typename promote< T, U >::V, Dim0, Dim12, i, j, k > operator* (const U &d0, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim2 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b, const Number< Current_Dim0 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b, const Number< 1 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, j, k > &b, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_201 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_201 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, i, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_201 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, i, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim2 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3as_times_T3_201 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, i, j > &b, const Number< Current_Dim0 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V T3as_times_T3_201 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, i, j > &b, const Number< 1 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< B, U, Dim12, Dim0, Dim12, k, i, j > &b, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_120 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, k, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_120 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, k, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_120 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, k, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim2 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3as_times_T3_120 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, k, i > &b, const Number< Current_Dim0 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V T3as_times_T3_120 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, k, i > &b, const Number< 1 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, k, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< B, U, Dim12, Dim12, Dim0, j, k, i > &b, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_102 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, i, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_102 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, i, k > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_102 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, i, k > &b, const Number< Current_Dim0 > &, const Number< Current_Dim2 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3as_times_T3_102 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, i, k > &b, const Number< Current_Dim0 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V T3as_times_T3_102 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, i, k > &b, const Number< 1 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, j, i, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< B, U, Dim12, Dim0, Dim12, j, i, k > &b, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_210 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_210 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, j, i > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_210 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, j, i > &b, const Number< Current_Dim0 > &, const Number< Current_Dim2 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3as_times_T3_210 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, j, i > &b, const Number< Current_Dim0 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V T3as_times_T3_210 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, j, i > &b, const Number< 1 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, k, j, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< B, U, Dim12, Dim12, Dim0, k, j, i > &b, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim1, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b, const Number< Current_Dim0 > &, const Number< 1 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0, int Current_Dim2>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b, const Number< Current_Dim0 > &, const Number< Current_Dim2 > &, const Number< Current_Dim2 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k, int Current_Dim0>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b, const Number< Current_Dim0 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V T3as_times_T3_012 (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b, const Number< 1 > &, const Number< 2 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a, const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim12, char i, char j, char k>
const promote< T, U >::V operator* (const Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > &b, const Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > &a)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim0, int Current_Dim1, int Current_Dim2, int Current_Dim3>
void T4_equals_T4 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim1, int Current_Dim2, int Current_Dim3>
void T4_equals_T4 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim2, int Current_Dim3>
void T4_equals_T4 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim3>
void T4_equals_T4 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
void T4_equals_T4 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim0, int Current_Dim1, int Current_Dim2, int Current_Dim3>
void T4_equals_T4_0312 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim1, int Current_Dim2, int Current_Dim3>
void T4_equals_T4_0312 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim2, int Current_Dim3>
void T4_equals_T4_0312 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l, int Current_Dim3>
void T4_equals_T4_0312 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim3 > &)
 
template<class A , class B , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
void T4_equals_T4_0312 (A &iter, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &result, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
 EQUAL (T4_equals_T4_2013, Dim2, Dim0, Dim1, Dim3, k, i, j, l, Current_Dim2 - 1, Current_Dim0 - 1, Current_Dim1 - 1, Current_Dim3 - 1, Current_Dim2 - 1, 0, Current_Dim1 - 1, Current_Dim3 - 1, Current_Dim2 - 1, 0, 0, Current_Dim3 - 1, 0, 0, 0, Current_Dim3 - 1)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_minus_Tensor4< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator- (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_minus_Tensor4_0312< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator- (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim3, Dim1, Dim2, i, l, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_minus_Tensor4_0321< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator- (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim3, Dim2, Dim1, i, l, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_minus_Tensor4_0213< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator- (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim2, Dim1, Dim3, i, k, j, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_minus_Tensor4_3201< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator- (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim3, Dim2, Dim0, Dim1, l, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_minus_Tensor4_0132< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator- (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim1, Dim3, Dim2, i, j, l, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_plus_Tensor4< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator+ (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_plus_Tensor4_0312< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator+ (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim3, Dim1, Dim2, i, l, j, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_plus_Tensor4_0321< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator+ (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim3, Dim2, Dim1, i, l, k, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_plus_Tensor4_0213< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator+ (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim2, Dim1, Dim3, i, k, j, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_plus_Tensor4_3201< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator+ (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim3, Dim2, Dim0, Dim1, l, k, i, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor4_Expr< const Tensor4_plus_Tensor4_0132< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim3, i, j, k, l > operator+ (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor4_Expr< B, U, Dim0, Dim1, Dim3, Dim2, i, j, l, k > &b)
 
template<class T , int Dim0, int Dim1, int Dim2, int Dim3, int Current_Dim0, int Current_Dim1, int Current_Dim2, int Current_Dim3>
void T4_increment (const Tensor4< T, Dim0, Dim1, Dim2, Dim3 > &iter, const Number< Current_Dim0 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class T , int Dim0, int Dim1, int Dim2, int Dim3, int Current_Dim1, int Current_Dim2, int Current_Dim3>
void T4_increment (const Tensor4< T, Dim0, Dim1, Dim2, Dim3 > &iter, const Number< 1 > &, const Number< Current_Dim1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class T , int Dim0, int Dim1, int Dim2, int Dim3, int Current_Dim2, int Current_Dim3>
void T4_increment (const Tensor4< T, Dim0, Dim1, Dim2, Dim3 > &iter, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim2 > &, const Number< Current_Dim3 > &)
 
template<class T , int Dim0, int Dim1, int Dim2, int Dim3, int Current_Dim3>
void T4_increment (const Tensor4< T, Dim0, Dim1, Dim2, Dim3 > &iter, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< Current_Dim3 > &)
 
template<class T , int Dim0, int Dim1, int Dim2, int Dim3>
void T4_increment (const Tensor4< T, Dim0, Dim1, Dim2, Dim3 > &iter, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &, const Number< 1 > &)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_3< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim3, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_3< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim2, i, j, k > operator* (const Tensor1_Expr< B, U, Dim3, l > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_2< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, j, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim2, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_2< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, j, l > operator* (const Tensor1_Expr< B, U, Dim2, k > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_1< A, B, T, U, Dim0, Dim2, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, Dim3, i, k, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim1, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim2, Dim3, i, k, l > operator* (const Tensor1_Expr< B, U, Dim1, j > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, Dim3, j, k, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor1_Expr< B, U, Dim0, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor3_Expr< const Tensor4_times_Tensor1_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, Dim3, j, k, l > operator* (const Tensor1_Expr< B, U, Dim0, i > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_23< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_23< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor2_Expr< B, U, Dim2, Dim3, k, l > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_32< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim3, Dim2, l, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_32< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor2_Expr< B, U, Dim3, Dim2, l, k > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_03< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim0, Dim3, i, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_03< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor2_Expr< B, U, Dim0, Dim3, i, l > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_30< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim3, Dim0, l, i > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_30< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor2_Expr< B, U, Dim3, Dim0, l, i > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_13< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim2, i, k > operator* (const Tensor2_Expr< B, U, Dim1, Dim3, j, l > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_3_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim4, i, j, k, m > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim3, Dim4, l, m > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_3_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim4, i, j, k, m > operator* (const Tensor2_Expr< B, U, Dim3, Dim4, l, m > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_3_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim4, i, j, k, m > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim4, Dim3, m, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_3_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim2, Dim4, i, j, k, m > operator* (const Tensor2_Expr< B, U, Dim4, Dim3, m, l > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_1_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim4, Dim2, Dim3, i, m, k, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim1, Dim4, j, m > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_1_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim4, Dim2, Dim3, i, m, k, l > operator* (const Tensor2_Expr< B, U, Dim1, Dim4, j, m > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_1_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim4, Dim2, Dim3, i, m, k, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim4, Dim1, m, j > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_1_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim4, Dim2, Dim3, i, m, k, l > operator* (const Tensor2_Expr< B, U, Dim4, Dim1, m, j > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_0_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim1, Dim1, Dim2, Dim3, m, j, k, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim0, Dim4, i, m > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_0_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim1, Dim1, Dim2, Dim3, m, j, k, l > operator* (const Tensor2_Expr< B, U, Dim0, Dim4, i, m > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_0_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim4, Dim1, Dim2, Dim3, m, j, k, l > operator* (const Tensor2_Expr< B, U, Dim4, Dim1, m, i > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_2_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim4, Dim3, i, j, m, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim2, Dim4, k, m > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_2_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim4, Dim3, i, j, m, l > operator* (const Tensor2_Expr< B, U, Dim2, Dim4, k, m > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_2_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim4, Dim3, i, j, m, l > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a, const Tensor2_Expr< B, U, Dim4, Dim2, m, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim2, int Dim3, int Dim4, char i, char j, char k, char l, char m>
const Tensor4_Expr< const Tensor4_times_Tensor2_2_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m >, typename promote< T, U >::V, Dim0, Dim1, Dim4, Dim3, i, j, m, l > operator* (const Tensor2_Expr< B, U, Dim4, Dim2, m, k > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_23< A, B, T, U, Dim0, Dim1, Dim, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, k, l > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_23< A, B, T, U, Dim0, Dim1, Dim, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor2_symmetric_Expr< B, U, Dim, k, l > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_32< A, B, T, U, Dim0, Dim1, Dim, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor4_Expr< A, T, Dim0, Dim1, Dim, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, l, k > &b)
 
template<class A , class B , class T , class U , int Dim0, int Dim1, int Dim, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_32< A, B, T, U, Dim0, Dim1, Dim, i, j, k, l >, typename promote< T, U >::V, Dim0, Dim1, i, j > operator* (const Tensor2_symmetric_Expr< B, U, Dim, l, k > &b, const Tensor4_Expr< A, T, Dim0, Dim1, Dim, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, int Dim2, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_03< A, B, T, U, Dim1, Dim2, Dim, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, l > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, int Dim2, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_03< A, B, T, U, Dim1, Dim2, Dim, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor2_symmetric_Expr< B, U, Dim, i, l > &b, const Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, int Dim2, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_30< A, B, T, U, Dim1, Dim2, Dim, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, l, i > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, int Dim2, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_30< A, B, T, U, Dim1, Dim2, Dim, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, k > operator* (const Tensor2_symmetric_Expr< B, U, Dim, l, i > &b, const Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > &a)
 
template<class A , class B , class T , class U , int Dim, int Dim1, int Dim2, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_02< A, B, T, U, Dim1, Dim2, Dim, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, l > operator* (const Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > &a, const Tensor2_symmetric_Expr< B, U, Dim, i, k > &b)
 
template<class A , class B , class T , class U , int Dim, int Dim1, int Dim2, char i, char j, char k, char l>
Tensor2_Expr< const Tensor4_times_Tensor2_symmetric_02< A, B, T, U, Dim1, Dim2, Dim, i, j, k, l >, typename promote< T, U >::V, Dim1, Dim2, j, l > operator* (const Tensor2_symmetric_Expr< B, U, Dim, i, k > &b, const Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > &a)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
std::ostream & Tensor4_0001 (std::ostream &os, const Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > &t, const int &iterator0, const int &iterator1, const int &iterator2)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
std::ostream & Tensor4_0010 (std::ostream &os, const Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > &t, const int &iterator0, const int &iterator1)
 
template<class T , int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3>
std::ostream & Tensor4_0100 (std::ostream &os, const Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > &t, const int &iterator0)
 

Detailed Description

JSON compatible output.

JSON compatible output. It only outputs unique, non-zero elments, so a 3x3 antisymmetric matrix only outputs 3 elements.

JSON compatible output. It only outputs unique elments, so a 3x3 symmetric matrix only outputs 6 elements.

JSON compatible output for numbers. If T is something funky (strings, arrays, etc.) then you are going to have a bad time.

JSON compatible input. It does not validate that separators are actually braces '[' or commas ','. It also ignores errors from missing trailing characters. So you could do something like

Tensor3<double,2,2,2> t3_1; std::stringstream ss(":::3:4:::7:8:::::11:12:::13:14"); ss >> t3_1;

Enumeration Type Documentation

◆ Layout

Enumerator
column_major 
row_major 

Definition at line 10 of file Layout.hpp.

Function Documentation

◆ conj()

template<class A , class T , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr<const conj_Tensor2<A,T,Dim0,Dim1,i,j>,T,Dim0,Dim1,i,j> FTensor::conj ( const Tensor2_Expr< A, T, Dim0, Dim1, i, j > &  a)

Definition at line 22 of file conj_Tensor2.hpp.

23  {
24  typedef const conj_Tensor2<A,T,Dim0,Dim1,i,j> TensorExpr;
25  return Tensor2_Expr<TensorExpr,T,Dim0,Dim1,i,j>(TensorExpr(a));
26  }

◆ cross()

template<class A , class B , class T , class U , char i, char j, char k>
auto FTensor::cross ( const Tensor1_Expr< A, T, 3, i > &  a,
const Tensor1_Expr< B, U, 3, j > &  b,
const Index< k, 3 > &   
)

Definition at line 11 of file cross.hpp.

14  {
15  return a*b*levi_civita(Index<i,3>(), Index<j,3>(), Index<k,3>());
16  }
constexpr std::enable_if<(Dim0<=2 &&Dim1<=2), Tensor2_Expr< Levi_Civita< T >, T, Dim0, Dim1, i, j > >::type levi_civita(const Index< i, Dim0 > &, const Index< j, Dim1 > &)
Definition: levi_civita.hpp:14
Definition: single.cpp:4

◆ d() [1/3]

template<class T , int Dim, char i>
const Tensor1_Expr<const dTensor0<T,Dim,i>,typename promote<T,double>::V,Dim,i> FTensor::d ( const Tensor0< T *> &  a,
const Index< i, Dim >  index,
const Tensor1< int, Dim > &  d_ijk,
const Tensor1< double, Dim > &  d_xyz 
)

Definition at line 26 of file dTensor0.hpp.

29  {
30  typedef const dTensor0<T,Dim,i> Tensor_Expr;
32  (Tensor_Expr(a,d_ijk,d_xyz));
33  }

◆ d() [2/3]

template<class T , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr<const dTensor2_symmetric<T,Dim01,Dim2,i,j,k>, typename promote<T,double>::V,Dim01,Dim2,i,j,k> FTensor::d ( const Tensor2_symmetric< T *, Dim01 > &  a,
const Index< i, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< k, Dim2 >  index3,
const Tensor1< int, Dim2 > &  d_ijk,
const Tensor1< double, Dim2 > &  d_xyz 
)

Definition at line 28 of file dTensor2_symmetric.hpp.

32  {
33  typedef const dTensor2_symmetric<T,Dim01,Dim2,i,j,k> TensorExpr;
34  return Dg_Expr<TensorExpr,typename promote<T,double>::V,Dim01,Dim2,i,j,k>
35  (TensorExpr(a,d_ijk,d_xyz));
36  }

◆ d() [3/3]

template<class T , int Dim0, int Dim1, char i, char j>
const Tensor2_Expr<const dTensor1<T,Dim0,Dim1,i,j>, typename promote<T,double>::V,Dim0,Dim1,i,j> FTensor::d ( const Tensor1< T *, Dim0 > &  a,
const Index< i, Dim0 >  index1,
const Index< j, Dim1 >  index2,
const Tensor1< int, Dim1 > &  d_ijk,
const Tensor1< double, Dim1 > &  d_xyz 
)

Definition at line 59 of file dTensor1.hpp.

63  {
64  typedef const dTensor1<T,Dim0,Dim1,i,j> TensorExpr;
65  return Tensor2_Expr<TensorExpr,typename promote<T,double>::V,Dim0,Dim1,i,j>
66  (TensorExpr(a,d_ijk,d_xyz));
67  }

◆ d_boundary() [1/2]

template<class T , int Dim, char i>
const Tensor1_Expr<const d_boundary_Tensor0<T,Dim,i>,typename promote<T,double>::V,Dim,i> FTensor::d_boundary ( const Tensor0< T *> &  a,
const Index< i, Dim >  index,
const Tensor1< int, Dim > &  d_ijk,
const Tensor1< double, Dim > &  d_xyz,
const Tensor2< bool, Dim, 2 > &  boundary 
)

Definition at line 32 of file d_boundary_Tensor0.hpp.

36  {
37  typedef const d_boundary_Tensor0<T,Dim,i> Tensor_Expr;
39  (Tensor_Expr(a,d_ijk,d_xyz,boundary));
40  }

◆ d_boundary() [2/2]

template<class T , int Dim01, int Dim2, char i, char j, char k>
const Dg_Expr<const d_boundary_Tensor2_symmetric<T,Dim01,Dim2,i,j,k>, typename promote<T,double>::V,Dim01,Dim2,i,j,k> FTensor::d_boundary ( const Tensor2_symmetric< T *, Dim01 > &  a,
const Index< i, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< k, Dim2 >  index3,
const Tensor1< int, Dim2 > &  d_ijk,
const Tensor1< double, Dim2 > &  d_xyz,
const Tensor2< bool, Dim2, 2 > &  boundary 
)

Definition at line 37 of file d_boundary_Tensor2_symmetric.hpp.

42  {
43  typedef const d_boundary_Tensor2_symmetric<T,Dim01,Dim2,i,j,k> TensorExpr;
44  return Dg_Expr<TensorExpr,typename promote<T,double>::V,Dim01,Dim2,i,j,k>
45  (TensorExpr(a,d_ijk,d_xyz,boundary));
46  }

◆ d_one_sided() [1/5]

template<class T >
const promote<T,double>::V FTensor::d_one_sided ( const Tensor0< T *> &  a,
const Number< 0 >  n1,
const int di,
const int dj,
const int dk,
const double dx,
const double dy,
const double dz 
)

Definition at line 10 of file d_one_sided_Tensor0.hpp.

14  {
15  return (a-*(&a-di))*dx;
16  }

◆ d_one_sided() [2/5]

template<class T >
const promote<T,double>::V FTensor::d_one_sided ( const Tensor0< T *> &  a,
const Number< 1 >  n1,
const int di,
const int dj,
const int dk,
const double dx,
const double dy,
const double dz 
)

Definition at line 20 of file d_one_sided_Tensor0.hpp.

24  {
25  return (a-*(&a-dj))*dy;
26  }

◆ d_one_sided() [3/5]

template<class T >
const promote<T,double>::V FTensor::d_one_sided ( const Tensor0< T *> &  a,
const Number< 2 >  n1,
const int di,
const int dj,
const int dk,
const double dx,
const double dy,
const double dz 
)

Definition at line 30 of file d_one_sided_Tensor0.hpp.

34  {
35  return (a-*(&a-dk))*dz;
36  }

◆ d_one_sided() [4/5]

template<class T , int Dim, char i, int axis>
const Tensor1_Expr<const d_one_sided_Tensor1<T,Dim,i,axis>, typename promote<T,double>::V,Dim,i> FTensor::d_one_sided ( const Tensor1< T *, Dim > &  a,
const Number< axis >  n1,
const Index< i, Dim >  index1,
const int di,
const int dj,
const int dk,
const double dx,
const double dy,
const double dz 
)

Definition at line 30 of file d_one_sided_Tensor1.hpp.

34  {
35  typedef const d_one_sided_Tensor1<T,Dim,i,axis> TensorExpr;
37  (TensorExpr(a,di,dj,dk,dx,dy,dz));
38  }

◆ d_one_sided() [5/5]

template<class T , int Dim, char i, char j, int axis>
const Tensor2_symmetric_Expr<const d_one_sided_Tensor2_symmetric<T,Dim,i,j,axis>, typename promote<T,double>::V,Dim,i,j> FTensor::d_one_sided ( const Tensor2_symmetric< T *, Dim > &  a,
const Number< axis >  n1,
const Index< i, Dim >  index1,
const Index< j, Dim >  index2,
const int di,
const int dj,
const int dk,
const double dx,
const double dy,
const double dz 
)

Definition at line 32 of file d_one_sided_Tensor2_symmetric.hpp.

37  {
38  typedef const d_one_sided_Tensor2_symmetric<T,Dim,i,j,axis> TensorExpr;
39  return Tensor2_symmetric_Expr<TensorExpr,typename promote<T,double>::V,Dim,i,j>
40  (TensorExpr(a,di,dj,dk,dx,dy,dz));
41  }

◆ dd() [1/3]

template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr<const ddTensor0<T,Dim,i,j>, typename promote<T,double>::V,Dim,i,j> FTensor::dd ( const Tensor0< T *> &  a,
const Index< i, Dim >  index1,
const Index< j, Dim >  index2,
const Tensor1< int, Dim > &  d_ijk,
const Tensor1< double, Dim > &  d_xyz 
)
Examples:
mesh_smoothing.cpp, simple_elasticity.cpp, and SmallStrainPlasticityMaterialModels.hpp.

Definition at line 32 of file ddTensor0.hpp.

34  {
35  typedef const ddTensor0<T,Dim,i,j> Tensor_Expr;
36  return Tensor2_symmetric_Expr<Tensor_Expr,typename promote<T,double>::V,Dim,i,j>
37  (Tensor_Expr(a,d_ijk,d_xyz));
38  }

◆ dd() [2/3]

template<class T , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr<const ddTensor2_symmetric<T,Dim01,Dim23,i,j,k,l>, typename promote<T,double>::V,Dim01,Dim23,i,j,k,l> FTensor::dd ( const Tensor2_symmetric< T *, Dim01 > &  a,
const Index< i, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< k, Dim23 >  index3,
const Index< l, Dim23 >  index4,
const Tensor1< int, Dim23 > &  d_ijk,
const Tensor1< double, Dim23 > &  d_xyz 
)

Definition at line 35 of file ddTensor2_symmetric.hpp.

39  {
40  typedef const ddTensor2_symmetric<T,Dim01,Dim23,i,j,k,l> Tensor_Expr;
41  return Ddg_Expr<Tensor_Expr,typename promote<T,double>::V,Dim01,Dim23,i,j,k,l>
42  (Tensor_Expr(a,d_ijk,d_xyz));
43  }

◆ dd() [3/3]

template<class T , int Dim0, int Dim12, char i, char j, char k>
const Dg_Expr<const ddTensor1<T,Dim0,Dim12,i,j,k>, typename promote<T,double>::V,Dim0,Dim12,i,j,k> FTensor::dd ( const Tensor1< T *, Dim0 > &  a,
const Index< k, Dim0 >  index0,
const Index< i, Dim12 >  index1,
const Index< j, Dim12 >  index2,
const Tensor1< int, Dim12 > &  d_ijk,
const Tensor1< double, Dim12 > &  d_xyz 
)

Definition at line 43 of file ddTensor1.hpp.

46  {
47  typedef const ddTensor1<T,Dim0,Dim12,i,j,k> TensorExpr;
48  return Dg_Expr<TensorExpr,typename promote<T,double>::V,Dim0,Dim12,i,j,k>
49  (TensorExpr(a,d_ijk,d_xyz));
50  }

◆ dd_boundary() [1/2]

template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr<const dd_boundary_Tensor0<T,Dim,i,j>, typename promote<T,double>::V,Dim,i,j> FTensor::dd_boundary ( const Tensor0< T *> &  a,
const Index< i, Dim >  index3,
const Index< j, Dim >  index4,
const Tensor1< int, Dim > &  d_ijk,
const Tensor1< double, Dim > &  d_xyz,
const Tensor2< bool, Dim, 2 > &  boundary 
)

Definition at line 75 of file dd_boundary_Tensor0.hpp.

79  {
80  typedef const dd_boundary_Tensor0<T,Dim,i,j> Tensor_Expr;
81  return Tensor2_symmetric_Expr<Tensor_Expr,typename promote<T,double>::V,Dim,i,j>
82  (Tensor_Expr(a,d_ijk,d_xyz,boundary));
83  }

◆ dd_boundary() [2/2]

template<class T , int Dim01, int Dim23, char i, char j, char k, char l>
const Ddg_Expr<const dd_boundary_Tensor2_symmetric<T,Dim01,Dim23,i,j,k,l>, typename promote<T,double>::V,Dim01,Dim23,i,j,k,l> FTensor::dd_boundary ( const Tensor2_symmetric< T *, Dim01 > &  a,
const Index< i, Dim01 >  index1,
const Index< j, Dim01 >  index2,
const Index< k, Dim23 >  index3,
const Index< l, Dim23 >  index4,
const Tensor1< int, Dim23 > &  d_ijk,
const Tensor1< double, Dim23 > &  d_xyz,
const Tensor2< bool, Dim23, 2 > &  boundary 
)

Definition at line 76 of file dd_boundary_Tensor2_symmetric.hpp.

81  {
82  typedef const dd_boundary_Tensor2_symmetric<T,Dim01,Dim23,i,j,k,l> Tensor_Expr;
83  return Ddg_Expr<Tensor_Expr,
84  typename promote<T,double>::V,Dim01,Dim23,i,j,k,l>
85  (Tensor_Expr(a,d_ijk,d_xyz,boundary));
86  }

◆ DECLARE_PROMOTE() [1/6]

FTensor::DECLARE_PROMOTE ( int  ,
double  ,
double   
)

◆ DECLARE_PROMOTE() [2/6]

FTensor::DECLARE_PROMOTE ( double  ,
int  ,
double   
)

◆ DECLARE_PROMOTE() [3/6]

FTensor::DECLARE_PROMOTE ( int  ,
std::complex< double ,
std::complex< double  
)

◆ DECLARE_PROMOTE() [4/6]

FTensor::DECLARE_PROMOTE ( std::complex< double ,
int  ,
std::complex< double  
)

◆ DECLARE_PROMOTE() [5/6]

FTensor::DECLARE_PROMOTE ( double  ,
std::complex< double ,
std::complex< double  
)

◆ DECLARE_PROMOTE() [6/6]

FTensor::DECLARE_PROMOTE ( std::complex< double ,
double  ,
std::complex< double  
)

◆ diffusion() [1/3]

template<class T >
const promote<T,double>::V FTensor::diffusion ( const Tensor0< T *> &  a,
const int di,
const int dj,
const int dk,
const double dx 
)

Definition at line 10 of file diffusion_Tensor0.hpp.

12  {
13  return
14  ((*(&a+di) - 2*a + *(&a-di)) + (*(&a+dj) - 2*a + *(&a-dj))
15  + (*(&a+dk) - 2*a + *(&a-dk))
16  + ((*(&a+di+dj) + *(&a+di-dj) + *(&a-di+dj) + *(&a-di-dj) - 4*a)
17  + (*(&a+di+dk) + *(&a+di-dk) + *(&a-di+dk) + *(&a-di-dk) - 4*a)
18  + (*(&a+dj+dk) + *(&a+dj-dk) + *(&a-dj+dk) + *(&a-dj-dk) - 4*a))
19  /(std::sqrt(2.0)))*dx*dx;
20  }

◆ diffusion() [2/3]

template<class T , int Dim, char i>
const Tensor1_Expr<const diffusion_Tensor1<T,Dim,i>, typename promote<T,double>::V,Dim,i> FTensor::diffusion ( const Tensor1< T *, Dim > &  a,
const Index< i, Dim >  index1,
const int di,
const int dj,
const int dk,
const double dx 
)

Definition at line 39 of file diffusion_Tensor1.hpp.

42  {
43  typedef const diffusion_Tensor1<T,Dim,i> Tensor_Expr;
45  (Tensor_Expr(a,di,dj,dk,dx));
46  }

◆ diffusion() [3/3]

template<class T , int Dim, char i, char j>
const Tensor2_symmetric_Expr<const diffusion_Tensor2_symmetric<T,Dim,i,j>,typename promote<T,double>::V,Dim,i,j> FTensor::diffusion ( const Tensor2_symmetric< T *, Dim > &  a,
const Index< i, Dim >  index1,
const Index< j, Dim >  index2,
const int di,
const int dj,
const int dk,
const double dx 
)

Definition at line 40 of file diffusion_Tensor2_symmetric.hpp.

44  {
45  typedef const diffusion_Tensor2_symmetric<T,Dim,i,j> Tensor_Expr;
46  return Tensor2_symmetric_Expr<Tensor_Expr,typename promote<T,double>::V,Dim,i,j>
47  (Tensor_Expr(a,di,dj,dk,dx));
48  }

◆ EQUAL()

FTensor::EQUAL ( T4_equals_T4_2013  ,
Dim2  ,
Dim0  ,
Dim1  ,
Dim3  ,
,
,
,
,
Current_Dim2 -  1,
Current_Dim0 -  1,
Current_Dim1 -  1,
Current_Dim3 -  1,
Current_Dim2 -  1,
,
Current_Dim1 -  1,
Current_Dim3 -  1,
Current_Dim2 -  1,
,
,
Current_Dim3 -  1,
,
,
,
Current_Dim3 -  1 
)

◆ interpolate() [1/3]

template<class T >
const promote<T,double>::V FTensor::interpolate ( const Tensor0< T *> &  a,
const int di,
const int dj,
const int dk,
const int i0,
const int j0,
const int k0,
const double  distance[3],
const double  conjugate[3] 
)

Definition at line 13 of file interpolate_Tensor0.hpp.

17  {
18  return
19  conjugate[0]*conjugate[1]*conjugate[2]
20  * (*(&a + di*i0 + dj*j0 + dk*k0))
21  + distance[0]*conjugate[1]*conjugate[2]
22  * (*(&a + di*(i0+1) + dj*(j0) + dk*(k0)))
23  + conjugate[0]*distance[1]*conjugate[2]
24  * (*(&a + di*(i0) + dj*(j0+1) + dk*(k0)))
25  + distance[0]*distance[1]*conjugate[2]
26  * (*(&a + di*(i0+1) + dj*(j0+1) + dk*(k0)))
27  + conjugate[0]*conjugate[1]*distance[2]
28  * (*(&a + di*(i0) + dj*(j0) + dk*(k0+1)))
29  + distance[0]*conjugate[1]*distance[2]
30  * (*(&a + di*(i0+1) + dj*(j0) + dk*(k0+1)))
31  + conjugate[0]*distance[1]*distance[2]
32  * (*(&a + di*(i0) + dj*(j0+1) + dk*(k0+1)))
33  + distance[0]*distance[1]*distance[2]
34  * (*(&a + di*(i0+1) + dj*(j0+1) + dk*(k0+1)));
35  }

◆ interpolate() [2/3]

template<class T , int Dim, char i>
const Tensor1_Expr<const interpolate_Tensor1