eigen.hpp

Go to the documentation of this file.

#pragma once
 
#include "./scalar.hpp"
 
#include <Eigen/Dense>
 
#include <cstddef>
 
namespace algotradelib {
namespace math {

// The only header that names Eigen in a public signature; a second backend is a sibling header.

using Matrix = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>;

using Vector = Eigen::Matrix<Scalar, Eigen::Dynamic, 1>;

using SeriesView = Eigen::Ref<const Vector>;

using MutableSeriesView = Eigen::Ref<Vector>;

using MatrixView = Eigen::Ref<const Matrix>;

using Index = Eigen::Index;

inline Vector unobserved(std::size_t count) {
  return Vector::Constant(static_cast<Index>(count), missing());
}

inline Matrix unobserved(std::size_t rows, std::size_t columns) {
  return Matrix::Constant(static_cast<Index>(rows), static_cast<Index>(columns), missing());
}

struct Observed {
  Vector values_;
  Vector present_;
};

inline Observed observed_parts(SeriesView values) {
  // `x == x` is false exactly for NaN, and vectorizes to a single compare.
  const auto present = (values.array() == values.array());
  Observed parts;
  parts.values_ = present.select(values, Scalar{0});
  parts.present_ = present.template cast<Scalar>();
  return parts;
}

inline Vector observed_or(SeriesView values, Scalar filler) {
  return (values.array() == values.array()).select(values, filler);
}

inline Vector both_present(const Vector& left, const Vector& right) {
  return left.cwiseProduct(right);
}

inline constexpr unsigned int LOWER = Eigen::Lower;
inline constexpr unsigned int UPPER = Eigen::Upper;
inline constexpr unsigned int UNIT_LOWER = Eigen::UnitLower;
inline constexpr unsigned int UNIT_UPPER = Eigen::UnitUpper;

using Llt = Eigen::LLT<Matrix>;

using Ldlt = Eigen::LDLT<Matrix>;

using HouseholderQr = Eigen::HouseholderQR<Matrix>;

using ColPivQr = Eigen::ColPivHouseholderQR<Matrix>;

using FullPivQr = Eigen::FullPivHouseholderQR<Matrix>;

using FullPivLu = Eigen::FullPivLU<Matrix>;

#if EIGEN_VERSION_AT_LEAST(3, 4, 90)
using Svd = Eigen::BDCSVD<Matrix, Eigen::ComputeThinU | Eigen::ComputeThinV>;
#else
using Svd = Eigen::BDCSVD<Matrix>;
#endif

inline Svd thin_svd(const Matrix& a) {
#if EIGEN_VERSION_AT_LEAST(3, 4, 90)
  return Svd(a);
#else
  return Svd(a, Eigen::ComputeThinU | Eigen::ComputeThinV);
#endif
}

using SelfAdjointEigen = Eigen::SelfAdjointEigenSolver<Matrix>;

inline constexpr auto SUCCESS = Eigen::Success;
 
} // namespace math
} // namespace algotradelib