utils.hpp

Go to the documentation of this file.

#ifndef SXEVAL_UTILS_HPP
#define SXEVAL_UTILS_HPP
 
#include <type_traits>
#include <cmath>
#include <stdexcept>
#include <cstdio>
#include <limits>
 
#define SXEVAL_PI 3.14159265358979323846
 
 
/* DEFINITIONS */
 
namespace sxeval {
 
template<typename T>
T StringToType(const std::string& s);
 
template<typename T>
inline bool Greater(const T& a, const T& b) {
    return a > b;
}
 
template<typename T>
inline typename std::enable_if<std::is_integral<T>::value, bool>::type
Equal(const T& a, const T& b) {
        return a == b;
}
 
template<typename T>
inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type
Equal(const T& a, const T& b) {
    return std::abs(a - b) <= std::numeric_limits<T>::epsilon();
}
 
template<typename T>
inline bool NotEqual(const T& a, const T& b) {
    return !Equal<T>(a, b);
}
 
template<typename T>
inline bool GreaterOrEqual(const T& a, const T& b) {
    return Greater<T>(a, b) || Equal<T>(a, b);
}
 
template<typename T>
inline bool Less(const T& a, const T& b) {
    return !GreaterOrEqual<T>(a, b);
}
 
template<typename T>
inline bool LessOrEqual(const T& a, const T& b) {
    return Less<T>(a, b) || Equal<T>(a, b);
}
 
template<typename T>
inline typename std::enable_if<std::is_integral<T>::value, bool>::type
TypeToBool(const T& val) {
    return val != 0;
}
 
template<typename T>
inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type
TypeToBool(const T& val) {
    return std::abs(val) > std::numeric_limits<T>::epsilon();
}
 
template<typename T>
inline bool LogicalAnd(const T& a, const T& b) {
    return TypeToBool<T>(a) && TypeToBool<T>(b);
}
 
template<typename T>
inline bool LogicalOr(const T& a, const T& b) {
    return TypeToBool<T>(a) || TypeToBool<T>(b);
}
 
template<typename T>
inline bool LogicalNot(const T& a) {
    return !TypeToBool<T>(a);
}
 
template<typename T>
inline bool LogicalXor(const T& a, const T& b) {
    return TypeToBool<T>(a) != TypeToBool<T>(b);
}
 
template<typename T>
inline bool LogicalNand(const T& a, const T& b) {
    return !LogicalAnd<T>(a, b);
}
 
template<typename T>
inline bool LogicalNor(const T& a, const T& b) {
    return !LogicalOr<T>(a, b);
}
 
template<typename T>
inline bool LogicalXnor(const T& a, const T& b) {
    return !LogicalXor<T>(a, b);
}
 
template<typename T>
inline typename std::enable_if<std::is_integral<T>::value, T>::type
Modulo(const T& a, const T& b) {
    return a % b;
}
 
template<typename T>
inline typename std::enable_if<std::is_floating_point<T>::value, T>::type
Modulo(const T& a, const T& b) {
    return std::fmod(a, b);
}
 
template<typename T>
inline typename std::enable_if<std::is_unsigned<T>::value, T>::type
Absolute(const T& a) {
    return a;
}
 
template<typename T>
inline typename std::enable_if<
    std::is_integral<T>::value && !std::is_unsigned<T>::value, T>::type
Absolute(const T& a) {
    return std::abs(a);
}
 
template<typename T>
inline typename std::enable_if<
    std::is_floating_point<T>::value  && !std::is_unsigned<T>::value, T>::type
Absolute(const T& a) {
    return std::fabs(a);
}
 
} /* namespace sxeval */
 
 
/* IMPLEMENTATIONS */
 
template<>
inline int sxeval::StringToType<int>(const std::string& s) {
    int res;
    if (sscanf(s.c_str(), "%d", &res) != 1) {
        throw std::invalid_argument("Invalid int string");
    }
    return res;
}
 
template<>
inline signed char sxeval::StringToType<signed char>(const std::string& s) {
    signed char res;
    if (sscanf(s.c_str(), "%hhd", &res) != 1) {
        throw std::invalid_argument("Invalid signed char string");
    }
    return res;
}
 
template<>
inline short int sxeval::StringToType<short int>(const std::string& s) {
    short int res;
    if (sscanf(s.c_str(), "%hd", &res) != 1) {
        throw std::invalid_argument("Invalid short int string");
    }
    return res;
}
 
template<>
inline long int sxeval::StringToType<long int>(const std::string& s) {
    long int res;
    if (sscanf(s.c_str(), "%ld", &res) != 1) {
        throw std::invalid_argument("Invalid long int string");
    }
    return res;
}
 
template<>
inline unsigned int sxeval::StringToType<unsigned int>(const std::string& s) {
    unsigned int res;
    if (sscanf(s.c_str(), "%u", &res) != 1) {
        throw std::invalid_argument("Invalid unsigned int string");
    }
    return res;
}
 
template<>
inline unsigned char sxeval::StringToType<unsigned char>(const std::string& s) {
    unsigned char res;
    if (sscanf(s.c_str(), "%hhu", &res) != 1) {
        throw std::invalid_argument("Invalid unsigned char string");
    }
    return res;
}
 
template<>
inline unsigned long int sxeval::StringToType<unsigned long int>(
    const std::string& s)
{
    unsigned long int res;
    if (sscanf(s.c_str(), "%lu", &res) != 1) {
        throw std::invalid_argument("Invalid unsigned long int string");
    }
    return res;
}
 
template<>
inline float sxeval::StringToType<float>(const std::string& s) {
    float res;
    if (sscanf(s.c_str(), "%f", &res) != 1) {
        throw std::invalid_argument("Invalid float string");
    }
    return res;
}
 
template<>
inline double sxeval::StringToType<double>(const std::string& s) {
    double res;
    if (sscanf(s.c_str(), "%lf", &res) != 1) {
        throw std::invalid_argument("Invalid double string");
    }
    return res;
}
 
template<>
inline long double sxeval::StringToType<long double>(const std::string& s)
{
    long double res;
    if (sscanf(s.c_str(), "%Lf", &res) != 1) {
        throw std::invalid_argument("Invalid long double string");
    }
    return res;
}
 
#endif /* SXEVAL_UTILS_HPP */