general.h

Go to the documentation of this file.

 
#ifndef GENERAL_H
#define GENERAL_H
 
#include <argos3/core/utility/datatypes/datatypes.h>
#include <vector>
#include <utility>
#include <cmath>
 
namespace argos {
    /****************************************/
    /****************************************/
 
    template<typename T> T Abs(const T& t_v) {
        if (t_v > T(0)) return t_v;
        if (t_v < T(0)) return -t_v;
        return T(0);
    }
 
    inline SInt32 Abs(SInt32 t_v) {
        if (t_v > 0) return t_v;
        if (t_v < 0) return -t_v;
        return 0;
    }
 
    inline Real Abs(Real t_v) {
        if (t_v > 0.0f) return t_v;
        if (t_v < 0.0f) return -t_v;
        return 0.0f;
    }
 
    /****************************************/
    /****************************************/
 
#ifdef ARGOS_USE_DOUBLE
#define Log  ::log
#define Sqrt ::sqrt
#define Exp ::exp
#define Mod ::fmod
#else
#define Log ::logf
#define Sqrt ::sqrtf
#define Exp ::expf
#define Mod ::fmodf
#endif
 
    /****************************************/
    /****************************************/
 
    template<typename T> T Min(const T& t_v1, const T& t_v2) {
        return t_v1 < t_v2 ? t_v1 : t_v2;
    }
 
    template<typename T> T& Min(T& t_v1, T& t_v2) {
        return t_v1 < t_v2 ? t_v1 : t_v2;
    }
 
    template<typename T> T Max(const T& t_v1, const T& t_v2) {
        return t_v1 > t_v2 ? t_v1 : t_v2;
    }
 
    template<typename T> T& Max(T& t_v1, T& t_v2) {
        return t_v1 > t_v2 ? t_v1 : t_v2;
    }
 
    /****************************************/
    /****************************************/
 
    template<typename T> SInt32 Sign(const T& t_v) {
        if (t_v > T(0)) return 1;
        if (t_v < T(0)) return -1;
        return 0;
    }
 
    /****************************************/
    /****************************************/
 
    template<typename T> T Square(const T& t_v) {
        return t_v * t_v;
    }
 
    /****************************************/
    /****************************************/
 
    inline SInt32 Floor(Real f_value) {
        SInt32 nI = static_cast<SInt32> (f_value);
        if (f_value >= 0.0f) return nI;
        return nI - 1;
    }
 
    inline SInt32 Ceil(Real f_value) {
        SInt32 nI = static_cast<SInt32> (f_value);
        if (nI < f_value) return nI + 1;
        return nI;
    }
 
    inline SInt32 Round(Real f_value) {
        if (f_value > 0.0f) return Floor(f_value + 0.5f);
        return Ceil(f_value - 0.5f);
    }
 
    inline SInt32 RoundClosestToZero(Real f_value) {
        if (f_value > 0.0f) return Floor(f_value);
        return Ceil(f_value);
    }
 
    /****************************************/
    /****************************************/
 
    inline bool DoubleEqAbsolute(Real f_value1, Real f_value2, Real f_epsilon) {
        return Abs<Real > (f_value1 - f_value2) <= f_epsilon * Max<Real > (1.0f, Max<Real > (Abs<Real > (f_value1), Abs<Real > (f_value2)));
    }
 
    inline bool DoubleEq(Real f_value1, Real f_value2) {
        return Abs<Real > (f_value1 - f_value2) <= 0.0001f * Max<Real > (1.0f, Max<Real > (Abs<Real > (f_value1), Abs<Real > (f_value2)));
    }
 
    /****************************************/
    /****************************************/
 
    inline Real Interpolate(Real f_x, const std::vector<std::pair<Real, Real> >& c_points) {
        std::pair<Real, Real> cP0 = c_points.at(0);
        std::pair<Real, Real> cP1;
        for (UInt32 i = 1; i < c_points.size(); ++i) {
            cP1 = c_points.at(i);
            if (cP1.first >= f_x) {
                break;
            } else if (i < c_points.size() - 1) {
                cP0 = cP1;
            }
        }
        return (f_x * (cP0.second - cP1.second)) / (cP0.first - cP1.first)+(-cP1.first * cP0.second + cP0.first * cP1.second) / (cP0.first - cP1.first);;
    }
}
 
#endif