constants.h

Go to the documentation of this file.

// Copyright (c) 2019 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_CONSTANTS_H_
#define INCLUDE_JET_CONSTANTS_H_
 
#include <jet/macros.h>
#include <cmath>
#include <limits>
 
namespace jet {
 
// MARK: Zero
 
constexpr size_t kZeroSize = 0;
 
constexpr ssize_t kZeroSSize = 0;
 
template <typename T>
constexpr T zero() {
    return 0;
}
 
template <>
constexpr float zero<float>() {
    return 0.f;
}
 
template <>
constexpr double zero<double>() {
    return 0.0;
}
 
// MARK: One
 
constexpr size_t kOneSize = 1;
 
constexpr ssize_t kOneSSize = 1;
 
template <typename T>
constexpr T one() {
    return 1;
}
 
template <>
constexpr float one<float>() {
    return 1.f;
}
 
template <>
constexpr double one<double>() {
    return 1.0;
}
 
// MARK: Epsilon
 
constexpr float kEpsilonF = std::numeric_limits<float>::epsilon();
 
constexpr double kEpsilonD = std::numeric_limits<double>::epsilon();
 
// MARK: Max
 
constexpr size_t kMaxSize = std::numeric_limits<size_t>::max();
 
constexpr ssize_t kMaxSSize = std::numeric_limits<ssize_t>::max();
 
constexpr float kMaxF = std::numeric_limits<float>::max();
 
constexpr double kMaxD = std::numeric_limits<double>::max();
 
// MARK: Pi
 
constexpr float kPiF = 3.14159265358979323846264338327950288f;
 
constexpr double kPiD = 3.14159265358979323846264338327950288;
 
template <typename T>
constexpr T pi() {
    return static_cast<T>(kPiD);
}
 
template <>
constexpr float pi<float>() {
    return kPiF;
}
 
template <>
constexpr double pi<double>() {
    return kPiD;
}
 
// MARK: Pi/2
 
constexpr float kHalfPiF = 1.57079632679489661923132169163975144f;
 
constexpr double kHalfPiD = 1.57079632679489661923132169163975144;
 
template <typename T>
constexpr T halfPi() {
    return static_cast<T>(kHalfPiD);
}
 
template <>
constexpr float halfPi<float>() {
    return kHalfPiF;
}
 
template <>
constexpr double halfPi<double>() {
    return kHalfPiD;
}
 
// MARK: Pi/4
 
constexpr float kQuarterPiF = 0.785398163397448309615660845819875721f;
 
constexpr double kQuarterPiD = 0.785398163397448309615660845819875721;
 
template <typename T>
constexpr T quarterPi() {
    return static_cast<T>(kQuarterPiD);
}
 
template <>
constexpr float quarterPi<float>() {
    return kQuarterPiF;
}
 
template <>
constexpr double quarterPi<double>() {
    return kQuarterPiD;
}
 
// MARK: 2*Pi
 
constexpr float kTwoPiF = static_cast<float>(2.0 * kPiD);
 
constexpr double kTwoPiD = 2.0 * kPiD;
 
template <typename T>
constexpr T twoPi() {
    return static_cast<T>(kTwoPiD);
}
 
template <>
constexpr float twoPi<float>() {
    return kTwoPiF;
}
 
template <>
constexpr double twoPi<double>() {
    return kTwoPiD;
}
 
// MARK: 4*Pi
 
constexpr float kFourPiF = static_cast<float>(4.0 * kPiD);
 
constexpr double kFourPiD = 4.0 * kPiD;
 
template <typename T>
constexpr T fourPi() {
    return static_cast<T>(kFourPiD);
}
 
template <>
constexpr float fourPi<float>() {
    return kFourPiF;
}
 
template <>
constexpr double fourPi<double>() {
    return kFourPiD;
}
 
// MARK: 1/Pi
 
constexpr float kInvPiF = static_cast<float>(1.0 / kPiD);
 
constexpr double kInvPiD = 1.0 / kPiD;
 
template <typename T>
constexpr T invPi() {
    return static_cast<T>(kInvPiD);
}
 
template <>
constexpr float invPi<float>() {
    return kInvPiF;
}
 
template <>
constexpr double invPi<double>() {
    return kInvPiD;
}
 
// MARK: 1/2*Pi
 
constexpr float kInvTwoPiF = static_cast<float>(0.5 / kPiD);
 
constexpr double kInvTwoPiD = 0.5 / kPiD;
 
template <typename T>
constexpr T invTwoPi() {
    return static_cast<T>(kInvTwoPiD);
}
 
template <>
constexpr float invTwoPi<float>() {
    return kInvTwoPiF;
}
 
template <>
constexpr double invTwoPi<double>() {
    return kInvTwoPiD;
}
 
// MARK: 1/4*Pi
 
constexpr float kInvFourPiF = static_cast<float>(0.25 / kPiD);
 
constexpr double kInvFourPiD = 0.25 / kPiD;
 
template <typename T>
constexpr T invFourPi() {
    return static_cast<T>(kInvFourPiD);
}
 
template <>
constexpr float invFourPi<float>() {
    return kInvFourPiF;
}
 
template <>
constexpr double invFourPi<double>() {
    return kInvFourPiD;
}
 
// MARK: Physics
 
constexpr double kGravity = -9.8;
 
constexpr double kWaterDensity = 1000.0;
 
constexpr double kSpeedOfSoundInWater = 1482.0;
 
// MARK: Common enums
 
constexpr int kDirectionNone = 0;
 
constexpr int kDirectionLeft = 1 << 0;
 
constexpr int kDirectionRight = 1 << 1;
 
constexpr int kDirectionDown = 1 << 2;
 
constexpr int kDirectionUp = 1 << 3;
 
constexpr int kDirectionBack = 1 << 4;
 
constexpr int kDirectionFront = 1 << 5;
 
constexpr int kDirectionAll = kDirectionLeft | kDirectionRight |
                              kDirectionDown | kDirectionUp | kDirectionBack |
                              kDirectionFront;
 
}  // namespace jet
 
#endif  // INCLUDE_JET_CONSTANTS_H_