Eigen_NumTraits.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_FWD_FUN_EIGEN_NUMTRAITS_HPP
#define STAN_MATH_FWD_FUN_EIGEN_NUMTRAITS_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/core.hpp>
#include <stan/math/fwd/fun/read_fvar.hpp>
#include <stan/math/fwd/core.hpp>
#include <stan/math/fwd/core/std_numeric_limits.hpp>
#include <limits>
 
namespace Eigen {
 
template <typename T>
struct NumTraits<stan::math::fvar<T>> : GenericNumTraits<stan::math::fvar<T>> {
  enum {
    RequireInitialization = 1,
 
    ReadCost = 2 * NumTraits<double>::ReadCost,
 
    AddCost = 2 * NumTraits<T>::AddCost,
 
    MulCost = 3 * NumTraits<T>::MulCost + NumTraits<T>::AddCost
  };
 
  static int digits10() { return std::numeric_limits<double>::digits10; }
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<stan::math::fvar<T>, double, BinaryOp> {
  using ReturnType = stan::math::fvar<T>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<double, stan::math::fvar<T>, BinaryOp> {
  using ReturnType = stan::math::fvar<T>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<stan::math::fvar<T>, int, BinaryOp> {
  using ReturnType = stan::math::fvar<T>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<int, stan::math::fvar<T>, BinaryOp> {
  using ReturnType = stan::math::fvar<T>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<double, std::complex<stan::math::fvar<T>>,
                            BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<std::complex<stan::math::fvar<T>>, double,
                            BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<int, std::complex<stan::math::fvar<T>>, BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<std::complex<stan::math::fvar<T>>, int, BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<stan::math::fvar<T>, std::complex<double>,
                            BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<std::complex<double>, stan::math::fvar<T>,
                            BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<std::complex<double>,
                            std::complex<stan::math::fvar<T>>, BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
template <typename T, typename BinaryOp>
struct ScalarBinaryOpTraits<std::complex<stan::math::fvar<T>>,
                            std::complex<double>, BinaryOp> {
  using ReturnType = std::complex<stan::math::fvar<T>>;
};
 
namespace internal {
 
template <typename EigFvar, typename EigOut>
struct functor_has_linear_access<
    stan::math::read_fvar_functor<EigFvar, EigOut>> {
  enum { ret = 1 };
};
 
}  // namespace internal
}  // namespace Eigen
#endif