Constants.h

Go to the documentation of this file.

 
 
#pragma once
#include <cmath>
 
namespace HF {
 
    namespace SpatialStructures {
 
        constexpr float ROUNDING_PRECISION = 0.0001f; // Used to convert back to original value
        constexpr float FLOAT_PRECISION = 10000.0f;  
        constexpr float GROUND_OFFSET = 0.001f; 
        template<typename desired_type, typename numeric_type>
        inline constexpr desired_type DivideBy1(numeric_type n) {
            return static_cast<desired_type>(1) / static_cast<desired_type>(n);
        }
 
 
        float roundhf(float f, float p = FLOAT_PRECISION, float r = ROUNDING_PRECISION);
 
        float trunchf(float f, float p = 1000.0, float r = 0.001);
 
        template <typename numeric_type>
        numeric_type roundhf_tail(numeric_type f, int precision)
        {
            numeric_type r = 0; // final rounded value
            int precision_2 = precision * 10; // the precision one more than the one we are interested in
            r = std::round(f * precision_2);
            r = std::round(r * 0.1); // Move decimal one over and round again
            r = r / precision;
 
            return r;
        }
 
        template <typename numeric_type>
        inline constexpr numeric_type roundhf_tmp(
            numeric_type f,
            numeric_type p,
            numeric_type r
        ) { return std::round(f * p) * r;   }
 
        template <typename desired_type, typename numeric_type>
        inline constexpr desired_type roundhf_tmp(numeric_type f,   numeric_type p) {
            return roundhf_tmp(static_cast<desired_type>(f), DivideBy1<desired_type>(p), static_cast<desired_type>(p));
        }
        template <typename desired_type, typename numeric_type>
        inline constexpr desired_type roundhf_tmp(numeric_type f) {
            return roundhf_tmp(
                static_cast<desired_type>(f),
                DivideBy1<desired_type>(ROUNDING_PRECISION),
                static_cast<desired_type>(ROUNDING_PRECISION)
            );
        }
 
        template <typename numeric_type>
        inline constexpr numeric_type trunchf_tmp(
            numeric_type f,
            numeric_type p,
            numeric_type r
        ) { return std::trunc(f * p) * r; }
        
        template <typename desired_type, typename numeric_type>
        inline constexpr desired_type trunchf_tmp(numeric_type f, numeric_type p) {
            return trunchf_tmp(static_cast<desired_type>(f), DivideBy1<desired_type>(p), static_cast<desired_type>(p));
        }
        template <typename desired_type, typename numeric_type>
        inline constexpr desired_type trunchf_tmp(numeric_type f) {
            return trunchf_tmp(
                static_cast<desired_type>(f),
                DivideBy1<desired_type>(ROUNDING_PRECISION),
                static_cast<desired_type>(ROUNDING_PRECISION)
            );
        }
 
 
 
    }
}