MatrixFunction.cpp

Go to the documentation of this file.

#include <type_traits>
#include <FTensor.hpp>
#include <MoFEM.hpp>
#include <Includes.hpp>
#include <MatrixFunction.hpp>
#include <MatrixFunctionTemplate.hpp>
 
namespace EigenMatrix {
 
template <typename T1, typename T2, int Dim>
FTensor::Tensor2_symmetric<double, Dim>
getMatImpl(Val<T1, Dim> &t_val, Vec<T2, Dim> &t_vec, Fun<double> f) {
  return EigenMatrixImp<T1, T2, 3, Dim>(t_val, t_vec).getMat(f);
}
 
template <typename T1, typename T2, int Dim>
FTensor::Ddg<double, Dim, Dim>
getDiffMatImpl(Val<T1, Dim> &t_val, Vec<T2, Dim> &t_vec, Fun<double> f,
               Fun<double> d_f, const int nb) {
  switch (nb) {
  case 1:
    return EigenMatrixImp<T1, T2, 1, Dim>(t_val, t_vec).getDiffMat(f, d_f);
  case 2:
    return EigenMatrixImp<T1, T2, 2, Dim>(t_val, t_vec).getDiffMat(f, d_f);
  case 3:
    break;
  default:
    THROW_MESSAGE("third parameter should be 1,2 or 3");
  }
  return EigenMatrixImp<T1, T2, 3, Dim>(t_val, t_vec).getDiffMat(f, d_f);
};
 
template <typename T1, typename T2, typename S, int Dim>
FTensor::Ddg<double, Dim, Dim>
getDiffDiffMatImpl(Val<T1, Dim> &t_val, Vec<T2, Dim> &t_vec, Fun<double> f,
                   Fun<double> d_f, Fun<double> dd_f, S &t_S, const int nb) {
  if (nb < 1 || nb > 3)
    THROW_MESSAGE("third parameter should be 1,2 or 3");
  return EigenMatrixContractedHessianImp<T1, T2, Dim>(t_val, t_vec)
      .getDiffDiffMat(f, d_f, dd_f, t_S);
};
 
FTensor::Tensor2_symmetric<double, 3>
getMatSpecial(Val<double, 3> &t_val, Vec<double, 3> &t_vec, Fun<double> f) {
  return getMatImpl<double, double, 3>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 3>
getMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
              Vec<FTensor::PackPtr<double *, 9>, 3> &t_vec, Fun<double> f) {
  return getMatImpl<FTensor::PackPtr<double *, 3>,
                    FTensor::PackPtr<double *, 9>, 3>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 3>
getMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
              Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f) {
  return getMatImpl<FTensor::PackPtr<double *, 3>,
                    FTensor::CursorPtr<double *, 9>, 3>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 3>
getMatSpecial(Val<FTensor::CursorPtr<double *, 3>, 3> &t_val,
              Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f) {
  return getMatImpl<FTensor::CursorPtr<double *, 3>,
                    FTensor::CursorPtr<double *, 9>, 3>(t_val, t_vec, f);
}
 
FTensor::Ddg<double, 3, 3> getDiffMatSpecial(Val<double, 3> &t_val,
                                             Vec<double, 3> &t_vec,
                                             Fun<double> f, Fun<double> d_f,
                                             const int nb) {
  return getDiffMatImpl<double, double, 3>(t_val, t_vec, f, d_f, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
                  Vec<FTensor::PackPtr<double *, 9>, 3> &t_vec, Fun<double> f,
                  Fun<double> d_f, const int nb) {
  return getDiffMatImpl<FTensor::PackPtr<double *, 3>,
                        FTensor::PackPtr<double *, 9>, 3>(t_val, t_vec, f, d_f,
                                                          nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
                  Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f,
                  Fun<double> d_f, const int nb) {
  return getDiffMatImpl<FTensor::PackPtr<double *, 3>,
                        FTensor::CursorPtr<double *, 9>, 3>(t_val, t_vec, f,
                                                            d_f, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffMatSpecial(Val<FTensor::CursorPtr<double *, 3>, 3> &t_val,
                  Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f,
                  Fun<double> d_f, const int nb) {
  return getDiffMatImpl<FTensor::CursorPtr<double *, 3>,
                        FTensor::CursorPtr<double *, 9>, 3>(t_val, t_vec, f,
                                                            d_f, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<double, 3> &t_val, Vec<double, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 3, 3> &t_S, const int nb) {
  return getDiffDiffMatImpl<double, double, FTensor::Tensor2<double, 3, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
                      Vec<FTensor::PackPtr<double *, 9>, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 3, 3> &t_S, const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 3>,
                            FTensor::PackPtr<double *, 9>,
                            FTensor::Tensor2<double, 3, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
                      Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 3, 3> &t_S, const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 3>,
                            FTensor::CursorPtr<double *, 9>,
                            FTensor::Tensor2<double, 3, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<FTensor::CursorPtr<double *, 3>, 3> &t_val,
                      Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 3, 3> &t_S, const int nb) {
  return getDiffDiffMatImpl<FTensor::CursorPtr<double *, 3>,
                            FTensor::CursorPtr<double *, 9>,
                            FTensor::Tensor2<double, 3, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<double, 3> &t_val, Vec<double, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 3> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<double, double,
                            FTensor::Tensor2_symmetric<double, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
                      Vec<FTensor::PackPtr<double *, 9>, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 3> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 3>,
                            FTensor::PackPtr<double *, 9>,
                            FTensor::Tensor2_symmetric<double, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
                      Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 3> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 3>,
                            FTensor::CursorPtr<double *, 9>,
                            FTensor::Tensor2_symmetric<double, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3>
getDiffDiffMatSpecial(Val<FTensor::CursorPtr<double *, 3>, 3> &t_val,
                      Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 3> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<FTensor::CursorPtr<double *, 3>,
                            FTensor::CursorPtr<double *, 9>,
                            FTensor::Tensor2_symmetric<double, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Tensor2_symmetric<double, 2>
getMatSpecial(Val<double, 2> &t_val, Vec<double, 2> &t_vec, Fun<double> f) {
  return getMatImpl<double, double, 2>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 2>
getMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
              Vec<FTensor::PackPtr<double *, 4>, 2> &t_vec, Fun<double> f) {
  return getMatImpl<FTensor::PackPtr<double *, 2>,
                    FTensor::PackPtr<double *, 4>, 2>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 2>
getMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
              Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f) {
  return getMatImpl<FTensor::PackPtr<double *, 2>,
                    FTensor::CursorPtr<double *, 4>, 2>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 2>
getMatSpecial(Val<FTensor::CursorPtr<double *, 2>, 2> &t_val,
              Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f) {
  return getMatImpl<FTensor::CursorPtr<double *, 2>,
                    FTensor::CursorPtr<double *, 4>, 2>(t_val, t_vec, f);
}
 
FTensor::Tensor2_symmetric<double, 6>
getMatSpecial(Val<double, 6> &t_val, Vec<double, 6> &t_vec, Fun<double> f) {
  return getMatImpl<double, double, 6>(t_val, t_vec, f);
}
 
FTensor::Ddg<double, 2, 2> getDiffMatSpecial(Val<double, 2> &t_val,
                                             Vec<double, 2> &t_vec,
                                             Fun<double> f, Fun<double> d_f,
                                             const int nb) {
  return getDiffMatImpl<double, double, 2>(t_val, t_vec, f, d_f, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
                  Vec<FTensor::PackPtr<double *, 4>, 2> &t_vec, Fun<double> f,
                  Fun<double> d_f, const int nb) {
  return getDiffMatImpl<FTensor::PackPtr<double *, 2>,
                        FTensor::PackPtr<double *, 4>, 2>(t_val, t_vec, f, d_f,
                                                          nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
                  Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f,
                  Fun<double> d_f, const int nb) {
  return getDiffMatImpl<FTensor::PackPtr<double *, 2>,
                        FTensor::CursorPtr<double *, 4>, 2>(t_val, t_vec, f,
                                                            d_f, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffMatSpecial(Val<FTensor::CursorPtr<double *, 2>, 2> &t_val,
                  Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f,
                  Fun<double> d_f, const int nb) {
  return getDiffMatImpl<FTensor::CursorPtr<double *, 2>,
                        FTensor::CursorPtr<double *, 4>, 2>(t_val, t_vec, f,
                                                            d_f, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<double, 2> &t_val, Vec<double, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 2, 2> &t_S, const int nb) {
  return getDiffDiffMatImpl<double, double, FTensor::Tensor2<double, 2, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<double, 2> &t_val, Vec<double, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 2> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<double, double,
                            FTensor::Tensor2_symmetric<double, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
                      Vec<FTensor::PackPtr<double *, 4>, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 2, 2> &t_S, const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 2>,
                            FTensor::PackPtr<double *, 4>,
                            FTensor::Tensor2<double, 2, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
                      Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 2, 2> &t_S, const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 2>,
                            FTensor::CursorPtr<double *, 4>,
                            FTensor::Tensor2<double, 2, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<FTensor::CursorPtr<double *, 2>, 2> &t_val,
                      Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2<double, 2, 2> &t_S, const int nb) {
  return getDiffDiffMatImpl<FTensor::CursorPtr<double *, 2>,
                            FTensor::CursorPtr<double *, 4>,
                            FTensor::Tensor2<double, 2, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
                      Vec<FTensor::PackPtr<double *, 4>, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 2> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 2>,
                            FTensor::PackPtr<double *, 4>,
                            FTensor::Tensor2_symmetric<double, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
                      Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 2> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<FTensor::PackPtr<double *, 2>,
                            FTensor::CursorPtr<double *, 4>,
                            FTensor::Tensor2_symmetric<double, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2>
getDiffDiffMatSpecial(Val<FTensor::CursorPtr<double *, 2>, 2> &t_val,
                      Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec,
                      Fun<double> f, Fun<double> d_f, Fun<double> dd_f,
                      FTensor::Tensor2_symmetric<double, 2> &t_S,
                      const int nb) {
  return getDiffDiffMatImpl<FTensor::CursorPtr<double *, 2>,
                            FTensor::CursorPtr<double *, 4>,
                            FTensor::Tensor2_symmetric<double, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
    Vec<FTensor::PackPtr<double *, 4>, 2> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 2> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 2>, FTensor::PackPtr<double *, 4>,
      FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
    Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 2> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 2>, FTensor::CursorPtr<double *, 4>,
      FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2> getDiffDiffMatSpecial(
    Val<FTensor::CursorPtr<double *, 2>, 2> &t_val,
    Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 2> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::CursorPtr<double *, 2>, FTensor::CursorPtr<double *, 4>,
      FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
    Vec<FTensor::PackPtr<double *, 4>, 2> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 3>, 2> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 2>, FTensor::PackPtr<double *, 4>,
      FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 3>, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 2>, 2> &t_val,
    Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 3>, 2> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 2>, FTensor::CursorPtr<double *, 4>,
      FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 3>, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 2, 2> getDiffDiffMatSpecial(
    Val<FTensor::CursorPtr<double *, 2>, 2> &t_val,
    Vec<FTensor::CursorPtr<double *, 4>, 2> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 3>, 2> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::CursorPtr<double *, 2>, FTensor::CursorPtr<double *, 4>,
      FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 3>, 2>, 2>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
    Vec<FTensor::PackPtr<double *, 9>, 3> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 3> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 3>, FTensor::PackPtr<double *, 9>,
      FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
    Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 3> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 3>, FTensor::CursorPtr<double *, 9>,
      FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3> getDiffDiffMatSpecial(
    Val<FTensor::CursorPtr<double *, 3>, 3> &t_val,
    Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 3> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::CursorPtr<double *, 3>, FTensor::CursorPtr<double *, 9>,
      FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 1>, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
    Vec<FTensor::PackPtr<double *, 9>, 3> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 6>, 3> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 3>, FTensor::PackPtr<double *, 9>,
      FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 6>, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3> getDiffDiffMatSpecial(
    Val<FTensor::PackPtr<double *, 3>, 3> &t_val,
    Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 6>, 3> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::PackPtr<double *, 3>, FTensor::CursorPtr<double *, 9>,
      FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 6>, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
FTensor::Ddg<double, 3, 3> getDiffDiffMatSpecial(
    Val<FTensor::CursorPtr<double *, 3>, 3> &t_val,
    Vec<FTensor::CursorPtr<double *, 9>, 3> &t_vec, Fun<double> f,
    Fun<double> d_f, Fun<double> dd_f,
    FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 6>, 3> &t_S,
    const int nb) {
  return getDiffDiffMatImpl<
      FTensor::CursorPtr<double *, 3>, FTensor::CursorPtr<double *, 9>,
      FTensor::Tensor2_symmetric<FTensor::CursorPtr<double *, 6>, 3>, 3>(
      t_val, t_vec, f, d_f, dd_f, t_S, nb);
}
 
} // namespace EigenMatrix