to.h

Go to the documentation of this file.

#pragma once
#include "limit.h"
#include <cassert>
#include <stdexcept>
 
#ifdef _WIN32
#  ifdef __INTEL_COMPILER
#   pragma warning(disable:2557)
#  else
#   pragma warning(disable:4018)
#  endif
#endif
 
template <class D,class T>
constexpr D to(const T &t) {
    // SIMPLER VERSION - Just casts back in debug and checks value is the original
    D ret =  static_cast<D>(t);
#ifdef _DEBUG
    T back = static_cast<T>(ret);
    if (back != t) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    return ret;
}
 
// Checking to see if you get the same value back does not work if floating point is used (rounding).
//  Now use a different template override for double/float.
template <>
inline constexpr float to(const double& t) {
    float f = static_cast<float>(t);
#ifdef _DEBUG
    double back = f;
    if (back != t) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    return f;
}
template <class D>
constexpr D to(const double& d) {
#ifdef _DEBUG
    if (d > static_cast<double>(limits<D>::max())) 
        throw std::runtime_error("Numeric Conversion error.");
    if (d < static_cast<double>(limits<D>::lowest())) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    // SIMPLER VERSION - Just casts back in debug and checks value is the original
    D ret = static_cast<D>(d);
    return ret;
}
template <class D>
D constexpr to(const float &d) {
#ifdef _DEBUG
    if (d > static_cast<float>(limits<D>::max())) 
        throw std::runtime_error("Numeric Conversion error.");
    if (d < static_cast<float>(limits<D>::lowest())) 
        throw std::runtime_error("Numeric Conversion error.");
#endif
    D ret = static_cast<D>(d);
    return ret;
}
template <>
inline constexpr double to(const float &d) {
    double ret = static_cast<double>(d);
    return ret;
}
#ifdef _WIN32
# pragma warning(default:4018)
#endif
 
template <class D,class T>
D *check_cast(T *t) {
    D *d = (D *)t;
#ifdef _DEBUG
    D *d2 = dynamic_cast<D *>(t);
    assert(d2==d);
#endif
    return d;
}
 
template <class D,class T>
const D *check_cast(const T *t) {
    const D *d = (const D *)t;
    assert(dynamic_cast<const D *>(t)==d);
    return d;
}
 
PUSHWARNING
VSWARNING(5030)
template <class T>
[[clang::optnone]] constexpr const T safeDiv(const T num,const T denom,const T safeVal=0) {
    constexpr double safeFac = limits<double>::epsilon()*100.0;
    if (std::abs(denom) <= std::abs(num*safeFac)) 
        return safeVal;
    return num/denom;
}
 
[[clang::optnone]] static inline double safeSquare(const double v) {
    static constexpr double maxRad = 1e150;
    if (std::abs(v)>maxRad) return std::abs(v);
    return v*v;
}
POPWARNING
 
template <typename T>
struct set_constness_of { 
    template <typename U>
    struct by {
        using type = typename std::conditional<
            std::is_const<U>::value,
            typename std::add_const<T>::type,
            typename std::remove_const<T>::type
        >::type;
    };
};
 
// EoF