Tools.h

Go to the documentation of this file.

 
#ifndef JIXIE_SVD_TOOLS_H
#define JIXIE_SVD_TOOLS_H
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <Eigen/Dense>
#include <Eigen/Core>
#include <Eigen/SVD>
#pragma GCC diagnostic pop
 
#if !defined(__APPLE__) || defined(__i386__) || defined(__x86_64__)
#include <mmintrin.h>
#include <xmmintrin.h>
#endif
#include <cmath>
#include <random>
#include <chrono>
#include <iostream>
#include <iomanip>
 
namespace JIXIE
{
 
    template <bool B, class T = void>
    using enable_if_t = typename std::enable_if<B, T>::type;
 
    namespace MATH_TOOLS
    {
 
        inline float approx_rsqrt(float a)
        {
            // return 1.0f / std::sqrt(a);
#if !defined(__APPLE__) || defined(__i386__) || defined(__x86_64__)
            return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(a)));
#else
            return vgetq_lane_f32(vrsqrteq_f32(vld1q_dup_f32(&a)), 0);
#endif
        }
        inline float approx_rsqrt(float a) {…}
 
        inline float rsqrt(float a)
        {
            return (float)1.0f / std::sqrt(a);
 
            // float b = approx_rsqrt(a);
            // // Newton step with f(x) = a - 1/x^2
            // b = 0.5f * b * (3.0f - a * (b * b));
            // return b;
        }
        inline float rsqrt(float a) {…}
 
        inline double rsqrt(double a)
        {
            using std::sqrt;
            return 1 / sqrt(a);
        }
        inline double rsqrt(double a) {…}
    } // namespace MATH_TOOLS
    namespace MATH_TOOLS {…}
 
    namespace INTERNAL
    {
        using namespace std;
        template <class T, class Enable = void>
        struct ScalarTypeHelper
        {
            using type = typename T::Scalar;
        };
        struct ScalarTypeHelper {…};
        template <class T>
        struct ScalarTypeHelper<T, enable_if_t<is_arithmetic<T>::value>>
        {
            using type = T;
        };
        struct ScalarTypeHelper<T, enable_if_t<is_arithmetic<T>::value>> {…};
    } // namespace INTERNAL
    namespace INTERNAL {…}
 
    template <class T>
    using ScalarType = typename INTERNAL::ScalarTypeHelper<T>::type;
 
    template <class MatrixType>
    constexpr bool isSize(int m, int n)
    {
        return MatrixType::RowsAtCompileTime == m && MatrixType::ColsAtCompileTime == n;
    }
    constexpr bool isSize(int m, int n) {…}
 
} // namespace JIXIE
#endif