global.h

Go to the documentation of this file.

/*
 * Copyright 2015 Jaroslaw Glowacki
 * jarek (dot) glowacki (at) gmail (dot) com
 *
 * This file is part of algebra3d.
 *
 * algebra3d is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * algebra3d is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with algebra3d.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _ALGEBRA3D_GLOBAL_H_
#define _ALGEBRA3D_GLOBAL_H_

#include<limits>
#include<cmath>
#include<ostream>
#include<istream>

#define _PRECISION(FP_TYPE) ( \
    (sizeof(FP_TYPE) == sizeof(float)) * 1.0e-5 \
    + (sizeof(FP_TYPE) > sizeof(float)) * 1.0e-12\
    )

#define PRECISION _PRECISION(fpType)

#define PRECISION_D _PRECISION(double)

#define PRECISION_F _PRECISION(float)

#define _INF(FP_TYPE) (std::numeric_limits<FP_TYPE>::infinity())

#define INF _INF(fpType)

#define INF_D _INF(double)

#define INF_F _INF(float)

#define N_A_N (INF - INF)

#define N_A_N_D (INF_D - INF_D)

#define N_A_N_F (INF_F - INF_F)

namespace algebra3d {

template<class fpType>
inline int sign(const fpType &val) {
    // A branchless version
    return (val > 0) - (val < 0);
}

template<class fpType>
inline int signStar(const fpType &val) {
    // A branchless version
    return (val >= 0) - (val < 0);
}

template<class fpType>
inline bool isInf(const fpType &number) {
    return number == std::numeric_limits<fpType>::infinity()
            || -number == std::numeric_limits<fpType>::infinity();
}

template<class fpType>
inline bool isNaN(const fpType &number) {
    return number != number;
}

template<class fpType>
inline int compare(const fpType &d1, const fpType&d2, const fpType &precision =
PRECISION) {
    // A branchless version
    return (isNaN<fpType>(d1) || isNaN<fpType>(d2)) * 2 + (d1 - d2 > precision)
            - (d2 - d1 > precision);
}

template<class fpType>
fpType normalizeAngle(const fpType &angle);

template<class fpType>
inline fpType getAngleFromSinCose(fpType sinAlpha, fpType cosAlpha) {
    return acos(cosAlpha) * ((sinAlpha > 0.0) - (sinAlpha < 0.0));
}

} /* namespace algebra3d */

#endif /* _ALGEBRA3D_GLOBAL_H_ */