Math.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

 
#pragma once
 
#include <concepts>
#include <cstdint>
#include <optional>
#include <type_traits>
#include <Eigen/Core>
#include <Eigen/Dense>
#include <gcem.hpp>
#include <fmt/format.h>
 
#include "util/Assert.h"
 
namespace NAV::math
{

uint64_t factorial(uint64_t n);

template<std::floating_point T>
constexpr T round(const T& value, size_t digits)
{
    auto factor = std::pow(10, digits);
    return std::round(value * factor) / factor;
}

template<std::floating_point T>
constexpr T roundSignificantDigits(T value, size_t digits)
{
    if (value == 0.0) { return 0.0; }
    // LOG_DEBUG("value = {:.13e} --> Round to {} digits", value, digits);
    auto absVal = gcem::abs(value);
    auto log10 = static_cast<int32_t>(gcem::log10(absVal));
    auto exp = log10 + (log10 > 0 || (log10 == 0 && absVal >= 1.0));
    auto fac = static_cast<T>(digits) - static_cast<T>(exp);
    // LOG_DEBUG("  log10  = {}, exp = {}, fac = {}", log10, exp, fac);
    auto factor = static_cast<T>(gcem::pow(10.0, fac));
    // LOG_DEBUG("  factor = {:.0e} --> value * factor = {}", factor, value * factor);
    // LOG_DEBUG("  round = {} --> ... / factor = {}", gcem::round(value * factor), gcem::round(value * factor) / factor);
    return static_cast<T>(gcem::round(value * factor) / factor);
}

template<std::integral Out, size_t Bits, std::integral In>
constexpr Out interpretAs(In in)
{
    static_assert(Bits < sizeof(In) * 8);
    static_assert(Bits < sizeof(Out) * 8);
 
    constexpr size_t N = sizeof(Out) * 8 - Bits;
    return static_cast<Out>(static_cast<Out>((in & static_cast<In>(gcem::pow(2, Bits) - 1)) << N) >> N);
}

template<typename Derived>
Eigen::Matrix<typename Derived::Scalar, 3, 3> skewSymmetricMatrix(const Eigen::MatrixBase<Derived>& a)
{
    INS_ASSERT_USER_ERROR(a.cols() == 1, "Given Eigen Object must be a vector");
    INS_ASSERT_USER_ERROR(a.rows() == 3, "Given Vector must have 3 Rows");
 
    Eigen::Matrix<typename Derived::Scalar, 3, 3> skewMat;
    skewMat << 0, -a(2), a(1),
        a(2), 0, -a(0),
        -a(1), a(0), 0;
 
    return skewMat;
}

template<typename Derived>
Eigen::Matrix<typename Derived::Scalar, 3, 3> skewSymmetricMatrixSquared(const Eigen::MatrixBase<Derived>& a)
{
    INS_ASSERT_USER_ERROR(a.cols() == 1, "Given Eigen Object must be a vector");
    INS_ASSERT_USER_ERROR(a.rows() == 3, "Given Vector must have 3 Rows");
 
    Eigen::Matrix<typename Derived::Scalar, 3, 3> skewMat2;
    skewMat2 << std::pow(a(2), 2) + std::pow(a(1), 2), a(0) * a(1), a(0) * a(2),
        a(0) * a(1), std::pow(a(2), 2) + std::pow(a(0), 2), a(1) * a(2),
        a(0) * a(2), a(1) * a(2), std::pow(a(0), 2) + std::pow(a(1), 2);
 
    return skewMat2;
}

template<std::floating_point T>
T sec(const T& x)
{
    return 1.0 / std::cos(x);
}

template<std::floating_point T>
T csc(const T& x)
{
    return 1.0 / std::sin(x);
}

template<typename T>
int sgn(const T& val)
{
    return (T(0) < val) - (val < T(0));
}

template<typename Derived>
typename Derived::PlainObject expm(const Eigen::MatrixBase<Derived>& X, size_t order)
{
    INS_ASSERT_USER_ERROR(X.rows() == X.cols(), "Matrix exponential calculation only possible for n x n matrices");
 
    typename Derived::PlainObject e_X;
 
    if constexpr (Derived::RowsAtCompileTime == Eigen::Dynamic)
    {
        e_X = Eigen::MatrixBase<Derived>::Identity(X.rows(), X.cols());
    }
    else
    {
        e_X = Eigen::MatrixBase<Derived>::Identity();
    }
    typename Derived::PlainObject Xpower = X;
    for (size_t i = 1; i <= order; i++)
    {
        e_X += Xpower / static_cast<double>(math::factorial(i));
 
        if (i < order)
        {
            Xpower *= X;
        }
    }
 
    return e_X;
}

template<typename Derived>
std::optional<std::pair<Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime>,
                        Eigen::Vector<typename Derived::Scalar, Derived::RowsAtCompileTime>>>
    LtDLdecomp_outerProduct(const Eigen::MatrixBase<Derived>& Qmatrix)
{
    using Eigen::seq;
 
    auto n = Qmatrix.rows();
    Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime> Q = Qmatrix.template triangularView<Eigen::Lower>();
    Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime> L;
    Eigen::Vector<typename Derived::Scalar, Derived::RowsAtCompileTime> D;
 
    if constexpr (Derived::RowsAtCompileTime == Eigen::Dynamic)
    {
        L = Eigen::Matrix<typename Derived::Scalar, Eigen::Dynamic, Eigen::Dynamic>::Zero(n, n);
        D.setZero(n);
    }
    else
    {
        L = Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime>::Zero();
        D.setZero();
    }
 
    for (Eigen::Index i = n - 1; i >= 0; i--)
    {
        D(i) = Q(i, i);
        if (Q(i, i) <= 0.0) { return {}; }
        L(i, seq(0, i)) = Q(i, seq(0, i)) / std::sqrt(Q(i, i));
 
        for (Eigen::Index j = 0; j <= i - 1; j++)
        {
            Q(j, seq(0, j)) -= L(i, seq(0, j)) * L(i, j);
        }
        L(i, seq(0, i)) /= L(i, i);
    }
 
    return std::make_pair(L, D);
}

template<typename Derived>
std::optional<std::pair<Eigen::Matrix<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime>,
                        Eigen::Vector<typename Derived::Scalar, Derived::RowsAtCompileTime>>>
    LtDLdecomp_choleskyFact(const Eigen::MatrixBase<Derived>& Q)
{
    using Eigen::seq;
 
    auto n = Q.rows();
    typename Derived::PlainObject L = Q.template triangularView<Eigen::Lower>();
    Eigen::Vector<typename Derived::Scalar, Derived::RowsAtCompileTime> D;
    double cmin = 1;
 
    if constexpr (Derived::RowsAtCompileTime == Eigen::Dynamic) { D.setZero(n); }
    else { D.setZero(); }
 
    for (Eigen::Index j = n - 1; j >= 0; j--)
    {
        for (Eigen::Index i = n - 1; i >= j + 1; i--)
        {
            L(i, j) = (L(i, j) - L(seq(i + 1, n - 1), j).dot(L(seq(i + 1, n - 1), i))) / L(i, i);
        }
        double t = L(j, j) - L(seq(j + 1, n - 1), j).dot(L(seq(j + 1, n - 1), j));
        if (t <= 0.0) { return {}; }
        double c = t / L(j, j);
        cmin = std::min(c, cmin);
        L(j, j) = std::sqrt(t);
    }
    for (Eigen::Index i = 0; i < n; i++)
    {
        L.row(i).leftCols(i) /= L(i, i);
        D(i) = std::pow(L(i, i), 2.0);
        L(i, i) = 1;
    }
 
    return std::make_pair(L, D);
}

template<typename DerivedA, typename DerivedQ>
typename DerivedA::Scalar squaredNormVectorMatrix(const Eigen::MatrixBase<DerivedA>& a, const Eigen::MatrixBase<DerivedQ>& Q)
{
    static_assert(DerivedA::ColsAtCompileTime == Eigen::Dynamic || DerivedA::ColsAtCompileTime == 1);
    INS_ASSERT_USER_ERROR(a.cols() == 1, "Parameter 'a' has to be a vector");
    INS_ASSERT_USER_ERROR(a.rows() == Q.rows(), "Parameter 'a' and 'Q' need to have same size");
    INS_ASSERT_USER_ERROR(Q.cols() == Q.rows(), "Parameter 'Q' needs to be quadratic");
 
    return a.transpose() * Q.inverse() * a;
}

double normalCDF(double value);

template<typename Derived>
[[nodiscard]] typename Derived::PlainObject inverseSqrt(const Eigen::MatrixBase<Derived>& matrix)
{
    INS_ASSERT_USER_ERROR(matrix.rows() == matrix.cols(), "Only square matrix supported");
    if constexpr (std::is_floating_point_v<typename Derived::Scalar>)
    {
        return matrix.inverse().sqrt(); // Eigen::SelfAdjointEigenSolver<Eigen::MatrixX<T>>{ covMatrix }.operatorInverseSqrt();
    }
    else // Eigen gets problems with ceres::Jet in the .sqrt() function
    {
        Eigen::JacobiSVD<Eigen::MatrixX<typename Derived::Scalar>> svd(matrix.inverse(), Eigen::ComputeFullV);
        typename Derived::PlainObject sqrtInverse = svd.matrixV() * svd.singularValues().cwiseSqrt().asDiagonal() * svd.matrixV().transpose();
        INS_ASSERT_USER_ERROR(!sqrtInverse.hasNaN(), "The matrix is not invertible");
        return sqrtInverse;
    }
}

template<typename T>
T sign(const T& x, const T& y)
{
    // similar function 'sign' in fortran
    if (y >= 0.0)
    {
        return fabs(x);
    }
    return -1.0 * fabs(x);
}

template<typename Derived>
typename Derived::PlainObject lerp(const Eigen::MatrixBase<Derived>& a, const Eigen::MatrixBase<Derived>& b, auto t)
{
    return a + t * (b - a);
}

struct LerpSearchResult
{
    size_t l; 
    size_t u; 
    double t; 
};

LerpSearchResult lerpSearch(const auto& data, const auto& value)
{
    auto i = static_cast<size_t>(std::distance(data.begin(), std::upper_bound(data.begin(), data.end(), value)));
    if (i > 0) { i--; }
    if (i == data.size() - 1) { i--; }
    const auto& lb = data.at(i);
    const auto& ub = data.at(i + 1);
    double t = (value - lb) / (ub - lb);
 
    return { .l = i, .u = i + 1, .t = t };
}

auto bilinearInterpolation(const auto& tx, const auto& ty,
                           const auto& c00, const auto& c10,
                           const auto& c01, const auto& c11)
{
    auto a = c00 * (1.0 - tx) + c10 * tx;
    auto b = c01 * (1.0 - tx) + c11 * tx;
    return a * (1.0 - ty) + b * ty;
    // Alternative implementation:
    // return (1.0 - tx) * (1.0 - ty) * c00 + tx * (1.0 - ty) * c10 + (1.0 - tx) * ty * c01 + tx * ty * c11;
}

double calcEllipticalIntegral(double phi, double m);
 
} // namespace NAV::math