v0.14.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Private Attributes | Friends | List of all members
EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim > Struct Template Reference

#include <src/ftensor/src/MatrixFunctionTemplate.hpp>

Collaboration diagram for EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >:
[legend]

Public Types

using Val = const FTensor::Tensor1< T1, Dim >
 
using Vec = const FTensor::Tensor2< T2, Dim, Dim >
 
using Fun = boost::function< double(const double)>
 
using V = double
 
template<int N>
using Number = FTensor::Number< N >
 
template<char c>
using I = typename FTensor::Index< c, Dim >
 
using NumberNb = Number< NB >
 
using NumberDim = Number< Dim >
 

Public Member Functions

 EigenMatrixImp (Val &t_val, Vec &t_vec)
 
auto getMat (Fun f)
 Get matrix. More...
 
auto getDiffMat (Fun f, Fun d_f)
 Get derivative of matrix. More...
 
template<typename T >
auto getDiffDiffMat (Fun f, Fun d_f, Fun dd_f, T &t_S)
 Get second directive of matrix. More...
 

Private Attributes

ValtVal
 
VectVec
 
FTensor::Tensor2_symmetric< V, Dim > aM [Dim]
 
FTensor::Ddg< V, Dim, Dim > aMM [Dim][Dim]
 
FTensor::Ddg< V, Dim, Dim > aG [Dim][Dim]
 
FTensor::Ddg< V, Dim, Dim > aS [(Dim *(Dim+1))/2]
 
FTensor::Ddg< V, Dim, Dim > aSM [(Dim - 1) *Dim][(Dim *(Dim+1))/2]
 
FTensor::Ddg< V, Dim, Dim > d2MType0 [Dim][(Dim *(Dim+1))/2]
 
FTensor::Ddg< V, Dim, Dim > d2MType1 [Dim][(Dim *(Dim+1))/2]
 
FTensor::Tensor2_symmetric< V, Dim > aF2
 
FTensor::Tensor2< V, Dim, Dim > aF
 
FTensor::Tensor1< V, Dim > fVal
 
FTensor::Tensor1< V, Dim > dfVal
 
FTensor::Tensor1< V, Dim > ddfVal
 

Friends

template<typename E , typename C >
struct d2MCoefficients
 
template<typename E , typename C , typename G >
struct d2MImpl
 
template<typename E , typename C >
struct Fdd4MImpl
 
template<typename E , typename C >
struct ReconstructMatImpl
 
template<typename E , typename C >
struct FirstMatrixDirectiveImpl
 
template<typename E , typename C >
struct SecondMatrixDirectiveImpl
 
template<typename E , typename C , typename T >
struct GetDiffMatImpl
 
template<typename E , typename C , typename T3 , typename T4 >
struct GetDiffDiffMatImpl
 

Detailed Description

template<typename T1, typename T2, int NB, int Dim>
struct EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >

Definition at line 799 of file MatrixFunctionTemplate.hpp.

Member Typedef Documentation

◆ Fun

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Fun = boost::function<double(const double)>

Definition at line 803 of file MatrixFunctionTemplate.hpp.

◆ I

template<typename T1 , typename T2 , int NB, int Dim>
template<char c>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::I = typename FTensor::Index<c, Dim>

Definition at line 807 of file MatrixFunctionTemplate.hpp.

◆ Number

template<typename T1 , typename T2 , int NB, int Dim>
template<int N>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Number = FTensor::Number<N>

Definition at line 806 of file MatrixFunctionTemplate.hpp.

◆ NumberDim

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::NumberDim = Number<Dim>

Definition at line 810 of file MatrixFunctionTemplate.hpp.

◆ NumberNb

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::NumberNb = Number<NB>

Definition at line 809 of file MatrixFunctionTemplate.hpp.

◆ V

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::V = double

Definition at line 804 of file MatrixFunctionTemplate.hpp.

◆ Val

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Val = const FTensor::Tensor1<T1, Dim>

Definition at line 801 of file MatrixFunctionTemplate.hpp.

◆ Vec

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Vec = const FTensor::Tensor2<T2, Dim, Dim>

Definition at line 802 of file MatrixFunctionTemplate.hpp.

Constructor & Destructor Documentation

◆ EigenMatrixImp()

template<typename T1 , typename T2 , int NB, int Dim>
EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::EigenMatrixImp ( Val t_val,
Vec t_vec 
)
inline

Definition at line 812 of file MatrixFunctionTemplate.hpp.

812 : tVal(t_val), tVec(t_vec) {
813
818
819 for (auto aa = 0; aa != Dim; ++aa) {
820 auto &M = aM[aa];
821 for (auto ii = 0; ii != Dim; ++ii)
822 for (auto jj = 0; jj <= ii; ++jj)
823 M(ii, jj) = tVec(aa, ii) * tVec(aa, jj);
824 }
825
826 for (auto aa = 0; aa != Dim; ++aa) {
827 for (auto bb = 0; bb != Dim; ++bb) {
828 auto &Ma = aM[aa];
829 auto &Mb = aM[bb];
830 auto &MM = aMM[aa][bb];
831 MM(i, j, k, l) = Ma(i, j) * Mb(k, l);
832 }
833 }
834
835 for (auto aa = 0; aa != Dim; ++aa) {
836 for (auto bb = 0; bb != Dim; ++bb) {
837 if (aa != bb) {
838 auto &MM = aMM[aa][bb];
839 auto &G = aG[aa][bb];
840 G(i, j, k, l) = MM(i, k, j, l) || MM(i, l, j, k);
841 }
842 }
843 }
844
845 for (auto aa = 0; aa != Dim; ++aa) {
846 for (auto bb = 0; bb != Dim; ++bb) {
847 if (aa != bb) {
848 auto &Gab = aG[aa][bb];
849 auto &Gba = aG[bb][aa];
850 auto &S = aS[get_sym_index(aa, bb, Dim)];
851 S(i, j, k, l) = Gab(i, j, k, l) + Gba(i, j, k, l);
852 }
853 }
854 }
855 }
static Index< 'M', 3 > M
FTensor::Index< 'i', SPACE_DIM > i
FTensor::Index< 'l', 3 > l
FTensor::Index< 'j', 3 > j
FTensor::Index< 'k', 3 > k
auto get_sym_index(const Number< N1 > &, const Number< N2 > &, const Number< Dim > &)
FTensor::Ddg< V, Dim, Dim > aMM[Dim][Dim]
FTensor::Ddg< V, Dim, Dim > aS[(Dim *(Dim+1))/2]
FTensor::Tensor2_symmetric< V, Dim > aM[Dim]
FTensor::Ddg< V, Dim, Dim > aG[Dim][Dim]

Member Function Documentation

◆ getDiffDiffMat()

template<typename T1 , typename T2 , int NB, int Dim>
template<typename T >
auto EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::getDiffDiffMat ( Fun  f,
Fun  d_f,
Fun  dd_f,
T t_S 
)
inline

Get second directive of matrix.

\[ LS_{klmn} = S_{ij} \frac{\partial^2 B_{ij}}{\partial A_{kl} \partial A_{mn} } \]

Template Parameters
T
Parameters
t_valeigen values vector
t_veceigen vectors matrix
ffunction
d_fderivative of function
dd_fsecond derivative of function
t_Ssecond rank tensor S
Returns
auto second derivatives, forth order tensor with minor symmetries

Definition at line 940 of file MatrixFunctionTemplate.hpp.

940 {
941
942 for (auto aa = 0; aa != Dim; ++aa)
943 fVal(aa) = f(tVal(aa));
944
945 for (auto aa = 0; aa != Dim; ++aa)
946 dfVal(aa) = d_f(tVal(aa));
947
948 for (auto aa = 0; aa != Dim; ++aa)
949 ddfVal(aa) = dd_f(tVal(aa));
950
951 for (auto aa = 0; aa != Dim; ++aa)
952 for (auto bb = 0; bb != aa; ++bb) {
953 aF(aa, bb) = 1 / (tVal(aa) - tVal(bb));
954 aF(bb, aa) = -aF(aa, bb);
955 aF2(aa, bb) = aF(aa, bb) * aF(aa, bb);
956 }
957
962
963 for (auto aa = 0; aa != Dim; ++aa) {
964 for (auto bb = 0; bb != Dim; ++bb) {
965 if (aa != bb) {
966 const auto &S = aS[get_sym_index(aa, bb, Dim)];
967 const auto &M = aM[aa];
968 auto &SMmn = aSM[get_nodiag_index(aa, bb, Dim)];
969 for (auto mm = 0; mm != Dim; ++mm) {
970 for (auto nn = mm; nn != Dim; ++nn) {
971 SMmn[get_sym_index(mm, nn, Dim)](i, j, k, l) =
972 S(i, j, k, l) * M(mm, nn);
973 }
974 }
975 }
976 }
977 }
978
979 for (auto aa = 0; aa != Dim; ++aa) {
980 for (auto mm = 0; mm != Dim; ++mm) {
981 for (auto nn = mm; nn != Dim; ++nn) {
982 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) = 0;
983 }
984 }
985 }
986
987 if constexpr (NB == 3)
988 for (auto aa = 0; aa != Dim; ++aa) {
989 for (auto bb = 0; bb != Dim; ++bb) {
990 if (aa != bb) {
991 const V v = dfVal(aa) * aF(aa, bb);
992 for (auto mm = 0; mm != Dim; ++mm) {
993 for (auto nn = mm; nn != Dim; ++nn) {
994 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
995 v * aSM[get_nodiag_index(aa, bb, Dim)]
996 [get_sym_index(mm, nn, Dim)](i, j, k, l);
997 }
998 }
999 }
1000 }
1001 }
1002
1003 if constexpr (NB == 2)
1004 for (auto aa = 0; aa != Dim; ++aa) {
1005 for (auto bb = 0; bb != Dim; ++bb) {
1006 if (aa != bb) {
1007 V v;
1008 if (aa == 1 || bb == 1)
1009 v = dfVal(aa) * aF(aa, bb);
1010 else
1011 v = ddfVal(aa) / 2;
1012 for (auto mm = 0; mm != Dim; ++mm) {
1013 for (auto nn = mm; nn != Dim; ++nn) {
1014 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
1015 v * aSM[get_nodiag_index(aa, bb, Dim)]
1016 [get_sym_index(mm, nn, Dim)](i, j, k, l);
1017 }
1018 }
1019 }
1020 }
1021 }
1022
1023 if constexpr (NB == 1)
1024 for (auto aa = 0; aa != Dim; ++aa) {
1025 for (auto bb = 0; bb != Dim; ++bb) {
1026 if (aa != bb) {
1027 const V v = ddfVal(aa) / 2;
1028 for (auto mm = 0; mm != Dim; ++mm) {
1029 for (auto nn = mm; nn != Dim; ++nn) {
1030 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
1031 v * aSM[get_nodiag_index(aa, bb, Dim)]
1032 [get_sym_index(mm, nn, Dim)](i, j, k, l);
1033 }
1034 }
1035 }
1036 }
1037 }
1038
1039 for (auto aa = 0; aa != Dim; ++aa) {
1040 for (auto mm = 0; mm != Dim; ++mm) {
1041 for (auto nn = 0; nn != Dim; ++nn) {
1042 if (nn != mm)
1043 d2MType1[mm][get_sym_index(aa, nn, Dim)](i, j, k, l) = 0;
1044 }
1045 }
1046 }
1047
1048 if constexpr (NB == 3)
1049 for (auto aa = 0; aa != Dim; ++aa) {
1050 for (auto bb = 0; bb != Dim; ++bb) {
1051 if (aa != bb) {
1052 const auto &S = aS[get_sym_index(aa, bb, Dim)];
1053 const auto v0 = aF(aa, bb);
1054 for (auto cc = 0; cc != Dim; ++cc) {
1055 for (auto dd = 0; dd != Dim; ++dd) {
1056 if (cc != dd) {
1057 const double v1 = fVal(cc) * aF(cc, dd);
1058 d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
1059 (v1 * v0) * S(i, j, k, l);
1060 }
1061 }
1062 }
1063 }
1064 }
1065 }
1066
1067 if constexpr (NB == 2)
1068 for (auto aa = 0; aa != Dim; ++aa) {
1069 for (auto bb = 0; bb != Dim; ++bb) {
1070 if (aa != bb)
1071 for (auto cc = 0; cc != Dim; ++cc) {
1072 for (auto dd = 0; dd != Dim; ++dd)
1073 if (cc != dd) {
1074
1075 V r;
1076
1077 if ((cc == 1 || dd == 1) && (aa == 1 || bb == 1))
1078 r = fVal(cc) * aF(cc, dd) * aF(aa, bb);
1079 else if (cc != 1 && dd != 1 && aa != 1 && bb != 1) {
1080
1081 if ((aa != bb && bb != dd) && (aa != dd && bb != cc))
1082 r = ddfVal(cc) / 4;
1083 else
1084 r = 0;
1085
1086 } else if ((cc != 1 && dd != 1) && (aa == 1 || bb == 1))
1087 r = dfVal(cc) * aF(aa, bb) / 2;
1088 else if ((cc == 1 || dd == 1) && (aa != 1 && bb != 1)) {
1089
1090 if ((cc == 2 && dd == 1) || (cc == 2 && dd == 1))
1091 r = (
1092
1093 dfVal(cc)
1094
1095 - (fVal(cc) - fVal(dd)) * aF(cc, dd)
1096
1097 ) *
1098 aF(cc, dd);
1099
1100 else
1101 r = 0;
1102
1103 } else
1104 r = 0;
1105
1106 if (r)
1107 d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
1108 r * aS[get_sym_index(aa, bb, Dim)](i, j, k, l);
1109 }
1110 }
1111 }
1112 }
1113
1114 if constexpr (NB == 1)
1115 for (auto aa = 0; aa != Dim; ++aa) {
1116 for (auto bb = 0; bb != Dim; ++bb) {
1117 if (aa != bb) {
1118 for (auto cc = 0; cc != Dim; ++cc) {
1119 for (auto dd = 0; dd != Dim; ++dd) {
1120 if (cc != dd) {
1121 if ((bb != dd) && (aa != dd && bb != cc)) {
1122 const double r = ddfVal(cc) / 4;
1123 d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
1124 r * aS[get_sym_index(aa, bb, Dim)](i, j, k, l);
1125 }
1126 }
1127 }
1128 }
1129 }
1130 }
1131 }
1132
1133 using THIS = EigenMatrixImp<T1, T2, NB, Dim>;
1134 using T3 = FTensor::Ddg<V, Dim, Dim>;
1135
1136 T3 t_diff_A;
1137 GetDiffDiffMatImpl<THIS, V, T3, T>(*this, t_diff_A, t_S)
1138 .set(Number<Dim>(), Number<Dim>(), Number<Dim>(), Number<Dim>());
1139 return t_diff_A;
1140 }
const double v
phase velocity of light in medium (cm/ns)
auto get_nodiag_index(const Number< N1 > &, const Number< N2 > &, const Number< Dim > &)
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)
Definition: ddTensor0.hpp:33
auto dd_f
Definition: HenckyOps.hpp:17
auto d_f
Definition: HenckyOps.hpp:16
int r
Definition: sdf.py:8
FTensor::Tensor1< V, Dim > fVal
FTensor::Ddg< V, Dim, Dim > d2MType0[Dim][(Dim *(Dim+1))/2]
FTensor::Tensor2_symmetric< V, Dim > aF2
FTensor::Ddg< V, Dim, Dim > d2MType1[Dim][(Dim *(Dim+1))/2]
FTensor::Tensor1< V, Dim > ddfVal
FTensor::Ddg< V, Dim, Dim > aSM[(Dim - 1) *Dim][(Dim *(Dim+1))/2]
FTensor::Tensor2< V, Dim, Dim > aF
FTensor::Tensor1< V, Dim > dfVal

◆ getDiffMat()

template<typename T1 , typename T2 , int NB, int Dim>
auto EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::getDiffMat ( Fun  f,
Fun  d_f 
)
inline

Get derivative of matrix.

\[ P_{ijkl} = \frac{\partial B_{ij}}{\partial A_{kl}} \]

Parameters
t_valeiegn values vector
t_veceiegn vectors matrix
ffunction
d_fdirective of function
Returns
auto derivatives, forth order tensor with minor simetries

Definition at line 900 of file MatrixFunctionTemplate.hpp.

900 {
901
902 for (auto aa = 0; aa != Dim; ++aa)
903 fVal(aa) = f(tVal(aa));
904
905 for (auto aa = 0; aa != Dim; ++aa)
906 dfVal(aa) = d_f(tVal(aa));
907
908 for (auto aa = 0; aa != Dim; ++aa)
909 for (auto bb = 0; bb != aa; ++bb) {
910 aF(aa, bb) = 1 / (tVal(aa) - tVal(bb));
911 aF(bb, aa) = -aF(aa, bb);
912 aF2(aa, bb) = aF(aa, bb) * aF(aa, bb);
913 }
914
915 using T3 = FTensor::Ddg<V, Dim, Dim>;
916 T3 t_diff_A;
917 GetDiffMatImpl<EigenMatrixImp<T1, T2, NB, Dim>, V, T3>(*this, t_diff_A)
918 .set(NumberDim(), NumberDim(), NumberDim(), NumberDim());
919 return t_diff_A;
920 }

◆ getMat()

template<typename T1 , typename T2 , int NB, int Dim>
auto EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::getMat ( Fun  f)
inline

Get matrix.

\[ \mathbf{B} = f(\mathbf{A}) \]

\[ B_{ij} = \sum_{a}^3 f(\lambda^a) n^a_i n^a_j \]

where \(a\) is eigen value number.

Parameters
t_valeiegn values vector
t_veceigen vectors matrix
ffunction
Returns
auto function symmetric tensor rank two

Definition at line 874 of file MatrixFunctionTemplate.hpp.

874 {
875
876 for (auto aa = 0; aa != Dim; ++aa)
877 fVal(aa) = f(tVal(aa));
878
879 using T3 =
881 T3 t_A;
882 GetMatImpl<EigenMatrixImp<T1, T2, NB, Dim>, V, T3>(*this, t_A)
883 .set(NumberDim(), NumberDim());
884 return t_A;
885 }

Friends And Related Function Documentation

◆ d2MCoefficients

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct d2MCoefficients
friend

Definition at line 1158 of file MatrixFunctionTemplate.hpp.

◆ d2MImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C , typename G >
friend struct d2MImpl
friend

Definition at line 1159 of file MatrixFunctionTemplate.hpp.

◆ Fdd4MImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct Fdd4MImpl
friend

Definition at line 1160 of file MatrixFunctionTemplate.hpp.

◆ FirstMatrixDirectiveImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct FirstMatrixDirectiveImpl
friend

Definition at line 1162 of file MatrixFunctionTemplate.hpp.

◆ GetDiffDiffMatImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C , typename T3 , typename T4 >
friend struct GetDiffDiffMatImpl
friend

Definition at line 1166 of file MatrixFunctionTemplate.hpp.

◆ GetDiffMatImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C , typename T >
friend struct GetDiffMatImpl
friend

Definition at line 1164 of file MatrixFunctionTemplate.hpp.

◆ ReconstructMatImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct ReconstructMatImpl
friend

Definition at line 1161 of file MatrixFunctionTemplate.hpp.

◆ SecondMatrixDirectiveImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct SecondMatrixDirectiveImpl
friend

Definition at line 1163 of file MatrixFunctionTemplate.hpp.

Member Data Documentation

◆ aF

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor2<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aF
private

Definition at line 1153 of file MatrixFunctionTemplate.hpp.

◆ aF2

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor2_symmetric<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aF2
private

Definition at line 1152 of file MatrixFunctionTemplate.hpp.

◆ aG

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aG[Dim][Dim]
private

Definition at line 1147 of file MatrixFunctionTemplate.hpp.

◆ aM

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor2_symmetric<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aM[Dim]
private

Definition at line 1145 of file MatrixFunctionTemplate.hpp.

◆ aMM

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aMM[Dim][Dim]
private

Definition at line 1146 of file MatrixFunctionTemplate.hpp.

◆ aS

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aS[(Dim *(Dim+1))/2]
private

Definition at line 1148 of file MatrixFunctionTemplate.hpp.

◆ aSM

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aSM[(Dim - 1) *Dim][(Dim *(Dim+1))/2]
private

Definition at line 1149 of file MatrixFunctionTemplate.hpp.

◆ d2MType0

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::d2MType0[Dim][(Dim *(Dim+1))/2]
private

Definition at line 1150 of file MatrixFunctionTemplate.hpp.

◆ d2MType1

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::d2MType1[Dim][(Dim *(Dim+1))/2]
private

Definition at line 1151 of file MatrixFunctionTemplate.hpp.

◆ ddfVal

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor1<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::ddfVal
private

Definition at line 1156 of file MatrixFunctionTemplate.hpp.

◆ dfVal

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor1<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::dfVal
private

Definition at line 1155 of file MatrixFunctionTemplate.hpp.

◆ fVal

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor1<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::fVal
private

Definition at line 1154 of file MatrixFunctionTemplate.hpp.

◆ tVal

template<typename T1 , typename T2 , int NB, int Dim>
Val& EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::tVal
private

Definition at line 1143 of file MatrixFunctionTemplate.hpp.

◆ tVec

template<typename T1 , typename T2 , int NB, int Dim>
Vec& EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::tVec
private

Definition at line 1144 of file MatrixFunctionTemplate.hpp.


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