FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 > Class Template Reference

#include <src/ftensor/src/FTensor/Ddg/Ddg_value.hpp>

Inheritance diagram for FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >:

Collaboration diagram for FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >:

Public Member Functions
T &	operator() (const int N1, const int N2, const int N3, const int N4)
T	operator() (const int N1, const int N2, const int N3, const int N4) const
template<int N1, int N2, int N3, int N4>
auto &	operator() (const Number< N1 > &, const Number< N2 > &, const Number< N3 > &, const Number< N4 > &)
template<int N1, int N2, int N3, int N4>
auto	operator() (const Number< N1 > &, const Number< N2 > &, const Number< N3 > &, const Number< N4 > &) const
template<char i, char j, char k, char l, int Dim01, int Dim23>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim23 >=Dim23), Ddg_Expr< Ddg< T, Tensor_Dim01, Tensor_Dim23 >, T, Dim01, Dim23, i, j, k, l > >::type	operator() (const Index< i, Dim01 >, const Index< j, Dim01 >, const Index< k, Dim23 >, const Index< l, Dim23 >)
template<char i, char j, char k, char l, int Dim01, int Dim23>
std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim23 >=Dim23), Ddg_Expr< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T, Dim01, Dim23, i, j, k, l > >::type	operator() (const Index< i, Dim01 >, const Index< j, Dim01 >, const Index< k, Dim23 >, const Index< l, Dim23 >) const
template<char i, char j, int N0, int N1, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim23 >=Dim), Tensor2_symmetric_Expr< Ddg_number_01< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0, N1 >, T, Dim, i, j > >::type	operator() (const Number< N0 >, const Number< N1 >, const Index< i, Dim >, const Index< j, Dim >) const
template<char i, char j, int N0, int N1, int Dim>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim23 >=Dim), Tensor2_symmetric_Expr< Ddg_number_rhs_01< Ddg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0, N1 >, T, Dim, i, j > >::type	operator() (const Number< N0 >, const Number< N1 >, const Index< i, Dim >, const Index< j, Dim >)
template<char i, char j, char k, int N0, int Dim1, int Dim23>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim23), Dg_Expr< Ddg_number_0< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0 >, T, Dim23, Dim1, i, j, k > >::type	operator() (const Number< N0 >, const Index< k, Dim1 >, const Index< i, Dim23 >, const Index< j, Dim23 >) const
template<char i, char j, char k, int N0, int Dim1, int Dim23>
std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim23), Dg_Expr< Ddg_number_rhs_0< Ddg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0 >, T, Dim23, Dim1, i, j, k > >::type	operator() (const Number< N0 >, const Index< k, Dim1 >, const Index< i, Dim23 >, const Index< j, Dim23 >)
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim23 >=Dim), Tensor2_symmetric_Expr< Ddg_numeral_01< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i, j > >::type	operator() (const int N0, const int N1, const Index< i, Dim >, const Index< j, Dim >) const
template<char i, char j, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim), Tensor2_symmetric_Expr< Ddg_numeral_23< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i, j > >::type	operator() (const Index< i, Dim >, const Index< j, Dim >, const int N2, const int N3) const
template<char i, char j, int Dim1, int Dim3>
std::enable_if<(Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim3), Tensor2_Expr< Ddg_numeral_02< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim1, Dim3, i, j > >::type	operator() (const int N0, const Index< i, Dim1 >, const int N2, const Index< j, Dim3 >) const
template<char i, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim), Tensor1_Expr< Ddg_numeral_123< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i > >::type	operator() (const Index< i, Dim >, const int N1, const int N2, const int N3)
template<char i, int Dim>
std::enable_if<(Tensor_Dim01 >=Dim), Tensor1_Expr< Ddg_numeral_123< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i > >::type	operator() (const int N1, const Index< i, Dim >, const int N2, const int N3)
template<char i, char j, char k, int Dim1, int Dim23>
std::enable_if<(Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim23), Dg_Expr< Ddg_numeral_0< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim23, Dim1, i, j, k > >::type	operator() (const int N0, const Index< k, Dim1 >, const Index< i, Dim23 >, const Index< j, Dim23 >) const

Private Attributes
T	data [(Tensor_Dim01 *(Tensor_Dim01+1))/2][(Tensor_Dim23 *(Tensor_Dim23+1))/2]

Detailed Description

template<class T, int Tensor_Dim01, int Tensor_Dim23>
class FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >

Examples

ElasticityMixedFormulation.hpp, EshelbianOperators.cpp, HookeElement.cpp, HookeElement.hpp, HookeInternalStressElement.hpp, PlasticOps.hpp, PlasticOpsGeneric.hpp, PlasticOpsLargeStrains.hpp, Remodeling.cpp, free_surface.cpp, matrix_function.cpp, and simple_elasticity.cpp.

Definition at line 7 of file Ddg_value.hpp.

Member Function Documentation

operator()() [1/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, int Dim>

std::enable_if<(Tensor_Dim01 >=Dim), Tensor2_symmetric_Expr< Ddg_numeral_23< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i, j > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Index< i, Dim >  , const Index< j, Dim >  , const int  N2, const int  N3  ) const

inline

Definition at line 230 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_numeral_23<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
        TensorExpr(*this, N2, N3));
    }

operator()() [2/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, int Dim>

std::enable_if<(Tensor_Dim01 >=Dim), Tensor1_Expr< Ddg_numeral_123< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Index< i, Dim >  , const int  N1, const int  N2, const int  N3  )

inline

Definition at line 262 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_numeral_123<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(
        TensorExpr(*this, N1, N2, N3));
    }

operator()() [3/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, char k, char l, int Dim01, int Dim23>

std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim23 >=Dim23), Ddg_Expr< Ddg< T, Tensor_Dim01, Tensor_Dim23 >, T, Dim01, Dim23, i, j, k, l > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Index< i, Dim01 >  , const Index< j, Dim01 >  , const Index< k, Dim23 >  , const Index< l, Dim23 >    )

inline

Definition at line 126 of file Ddg_value.hpp.

    {
      return Ddg_Expr<Ddg<T, Tensor_Dim01, Tensor_Dim23>, T, Dim01, Dim23, i,
                      j, k, l>(*this);
    }

operator()() [4/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, char k, char l, int Dim01, int Dim23>

std::enable_if<(Tensor_Dim01 >=Dim01 &&Tensor_Dim23 >=Dim23), Ddg_Expr< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T, Dim01, Dim23, i, j, k, l > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Index< i, Dim01 >  , const Index< j, Dim01 >  , const Index< k, Dim23 >  , const Index< l, Dim23 >    ) const

inline

Definition at line 137 of file Ddg_value.hpp.

    {
      return Ddg_Expr<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T, Dim01,
                      Dim23, i, j, k, l>(*this);
    }

operator()() [5/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, int Dim1, int Dim3>

std::enable_if<(Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim3), Tensor2_Expr< Ddg_numeral_02< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim1, Dim3, i, j > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const int  N0, const Index< i, Dim1 >  , const int  N2, const Index< j, Dim3 >    ) const

inline

Definition at line 246 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_numeral_02<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T>;
      return Tensor2_Expr<TensorExpr, T, Dim1, Dim3, i, j>(
        TensorExpr(*this, N0, N2));
    }

operator()() [6/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, char k, int Dim1, int Dim23>

std::enable_if<(Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim23), Dg_Expr< Ddg_numeral_0< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim23, Dim1, i, j, k > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const int  N0, const Index< k, Dim1 >  , const Index< i, Dim23 >  , const Index< j, Dim23 >    ) const

inline

Definition at line 292 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_numeral_0<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T>;
      return Dg_Expr<TensorExpr, T, Dim23, Dim1, i, j, k>(
        TensorExpr(*this, N0));
    }

operator()() [7/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, int Dim>

std::enable_if<(Tensor_Dim23 >=Dim), Tensor2_symmetric_Expr< Ddg_numeral_01< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i, j > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const int  N0, const int  N1, const Index< i, Dim >  , const Index< j, Dim >    ) const

inline

Definition at line 215 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_numeral_01<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
        TensorExpr(*this, N0, N1));
    }

operator()() [8/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, int Dim>

std::enable_if<(Tensor_Dim01 >=Dim), Tensor1_Expr< Ddg_numeral_123< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T >, T, Dim, i > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const int  N1, const Index< i, Dim >  , const int  N2, const int  N3  )

inline

Definition at line 275 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_numeral_123<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T>;
      return Tensor1_Expr<TensorExpr, T, Dim, i>(
        TensorExpr(*this, N1, N2, N3));
    }

operator()() [9/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

T & FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const int  N1, const int  N2, const int  N3, const int  N4  )

inline

Definition at line 17 of file Ddg_value.hpp.

    {
#ifdef FTENSOR_DEBUG
      if(N1 >= Tensor_Dim01 || N1 < 0 || N2 >= Tensor_Dim01 || N2 < 0
         || N3 >= Tensor_Dim23 || N3 < 0 || N4 >= Tensor_Dim23 || N4 < 0)
        {
          std::stringstream s;
          s << "Bad index in Dg<T," << Tensor_Dim01 << "," << Tensor_Dim23
            << ">.operator(" << N1 << "," << N2 << "," << N3 << "," << N4
            << ")" << std::endl;
          throw std::out_of_range(s.str());
        }
#endif
      return N1 > N2
               ? (N3 > N4 ? data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                                [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2]
                          : data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                                [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2])
               : (N3 > N4 ? data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                                [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2]
                          : data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                                [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2]);
    }

operator()() [10/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

T FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const int  N1, const int  N2, const int  N3, const int  N4  ) const

inline

Definition at line 41 of file Ddg_value.hpp.

    {
#ifdef FTENSOR_DEBUG
      if(N1 >= Tensor_Dim01 || N1 < 0 || N2 >= Tensor_Dim01 || N2 < 0
         || N3 >= Tensor_Dim23 || N3 < 0 || N4 >= Tensor_Dim23 || N4 < 0)
        {
          std::stringstream s;
          s << "Bad index in Dg<T," << Tensor_Dim01 << "," << Tensor_Dim23
            << ">.operator(" << N1 << "," << N2 << "," << N3 << "," << N4
            << ") const" << std::endl;
          throw std::out_of_range(s.str());
        }
#endif
      return N1 > N2
               ? (N3 > N4 ? data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                                [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2]
                          : data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                                [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2])
               : (N3 > N4 ? data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                                [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2]
                          : data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                                [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2]);
    }

operator()() [11/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, char k, int N0, int Dim1, int Dim23>

std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim23), Dg_Expr< Ddg_number_rhs_0< Ddg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0 >, T, Dim23, Dim1, i, j, k > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Number< N0 >  , const Index< k, Dim1 >  , const Index< i, Dim23 >  , const Index< j, Dim23 >    )

inline

Definition at line 197 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_number_rhs_0<Ddg<T, Tensor_Dim01, Tensor_Dim23>, T, N0>;
      return Dg_Expr<TensorExpr, T, Dim23, Dim1, i, j, k>(*this);
    }

operator()() [12/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, char k, int N0, int Dim1, int Dim23>

std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >=Dim1 &&Tensor_Dim23 >=Dim23), Dg_Expr< Ddg_number_0< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0 >, T, Dim23, Dim1, i, j, k > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Number< N0 >  , const Index< k, Dim1 >  , const Index< i, Dim23 >  , const Index< j, Dim23 >    ) const

inline

Definition at line 184 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_number_0<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T, N0>;
      return Dg_Expr<TensorExpr, T, Dim23, Dim1, i, j, k>(TensorExpr(*this));
    }

operator()() [13/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, int N0, int N1, int Dim>

std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim23 >=Dim), Tensor2_symmetric_Expr< Ddg_number_rhs_01< Ddg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0, N1 >, T, Dim, i, j > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Number< N0 >  , const Number< N1 >  , const Index< i, Dim >  , const Index< j, Dim >    )

inline

Definition at line 168 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_number_rhs_01<Ddg<T, Tensor_Dim01, Tensor_Dim23>, T, N0, N1>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(*this);
    }

operator()() [14/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<char i, char j, int N0, int N1, int Dim>

std::enable_if<(Tensor_Dim01 >N0 &&Tensor_Dim01 >N1 &&Tensor_Dim23 >=Dim), Tensor2_symmetric_Expr< Ddg_number_01< constDdg< T, Tensor_Dim01, Tensor_Dim23 >, T, N0, N1 >, T, Dim, i, j > >::type FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Number< N0 >  , const Number< N1 >  , const Index< i, Dim >  , const Index< j, Dim >    ) const

inline

Definition at line 153 of file Ddg_value.hpp.

    {
      using TensorExpr
        = Ddg_number_01<const Ddg<T, Tensor_Dim01, Tensor_Dim23>, T, N0, N1>;
      return Tensor2_symmetric_Expr<TensorExpr, T, Dim, i, j>(
        TensorExpr(*this));
    }

operator()() [15/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<int N1, int N2, int N3, int N4>

auto & FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Number< N1 > &  , const Number< N2 > &  , const Number< N3 > &  , const Number< N4 > &    )

inline

Definition at line 66 of file Ddg_value.hpp.

                                                                    {
 
      static_assert(N1 < Tensor_Dim01, "Bad index N1");
      static_assert(N2 < Tensor_Dim01, "Bad index N2");
      static_assert(N3 < Tensor_Dim23, "Bad index N3");
      static_assert(N4 < Tensor_Dim23, "Bad index N4");
 
      if constexpr (N1 > N2) {
        if constexpr (N3 > N4)
          return data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                     [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2];
        else
          return data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                     [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2];
      } else {
        if constexpr (N3 > N4)
          return data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                     [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2];
        else
          return data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                     [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2];
      }
    }

operator()() [16/16]

template<class T , int Tensor_Dim01, int Tensor_Dim23>

template<int N1, int N2, int N3, int N4>

auto FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::operator() ( const Number< N1 > &  , const Number< N2 > &  , const Number< N3 > &  , const Number< N4 > &    ) const

inline

Definition at line 92 of file Ddg_value.hpp.

                                                                         {
 
      static_assert(N1 < Tensor_Dim01, "Bad index N1");
      static_assert(N2 < Tensor_Dim01, "Bad index N2");
      static_assert(N3 < Tensor_Dim23, "Bad index N3");
      static_assert(N4 < Tensor_Dim23, "Bad index N4");
 
      if constexpr (N1 > N2) {
        if constexpr (N3 > N4)
          return data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                     [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2];
        else
          return data[N1 + (N2 * (2 * Tensor_Dim01 - N2 - 1)) / 2]
                     [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2];
      } else {
        if constexpr (N3 > N4)
          return data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                     [N3 + (N4 * (2 * Tensor_Dim23 - N4 - 1)) / 2];
        else
          return data[N2 + (N1 * (2 * Tensor_Dim01 - N1 - 1)) / 2]
                     [N4 + (N3 * (2 * Tensor_Dim23 - N3 - 1)) / 2];
      }
    }

Member Data Documentation

data

template<class T , int Tensor_Dim01, int Tensor_Dim23>

T FTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 >::data[(Tensor_Dim01 *(Tensor_Dim01+1))/2][(Tensor_Dim23 *(Tensor_Dim23+1))/2]

private

Definition at line 9 of file Ddg_value.hpp.

---

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

• src/ftensor/src/FTensor.hpp
• src/ftensor/src/FTensor/Ddg/Ddg_value.hpp