Math.cpp

Go to the documentation of this file.

#include "pch.h"
#include "System/Math.h"
#include "System/ArgumentException.h"
#include "System/ArgumentOutOfRangeException.h"
#include <cmath>
 
namespace DotNetDupe {
    namespace System {
 
        int Math::Abs(int iValue) {
            return std::abs(iValue);
        }
 
        long long Math::Abs(long long llValue) {
            return std::abs(llValue);
        }
 
        float Math::Abs(float fValue) {
            return std::fabs(fValue);
        }
 
        double Math::Abs(double dValue) {
            return std::fabs(dValue);
        }
 
        int Math::Max(int iVal1, int iVal2) {
            return (iVal1 >= iVal2) ? iVal1 : iVal2;
        }
 
        long long Math::Max(long long llVal1, long long llVal2) {
            return (llVal1 >= llVal2) ? llVal1 : llVal2;
        }
 
        float Math::Max(float fVal1, float fVal2) {
            return (fVal1 >= fVal2) ? fVal1 : fVal2;
        }
 
        double Math::Max(double dVal1, double dVal2) {
            return (dVal1 >= dVal2) ? dVal1 : dVal2;
        }
 
        int Math::Min(int iVal1, int iVal2) {
            return (iVal1 <= iVal2) ? iVal1 : iVal2;
        }
 
        long long Math::Min(long long llVal1, long long llVal2) {
            return (llVal1 <= llVal2) ? llVal1 : llVal2;
        }
 
        float Math::Min(float fVal1, float fVal2) {
            return (fVal1 <= fVal2) ? fVal1 : fVal2;
        }
 
        double Math::Min(double dVal1, double dVal2) {
            return (dVal1 <= dVal2) ? dVal1 : dVal2;
        }
 
        int Math::Clamp(int iValue, int iMin, int iMax) {
            if (iMin > iMax) throw ArgumentException("min cannot be greater than max.");
            if (iValue < iMin) return iMin;
            if (iValue > iMax) return iMax;
            return iValue;
        }
 
        long long Math::Clamp(long long llValue, long long llMin, long long llMax) {
            if (llMin > llMax) throw ArgumentException("min cannot be greater than max.");
            if (llValue < llMin) return llMin;
            if (llValue > llMax) return llMax;
            return llValue;
        }
 
        double Math::Clamp(double dValue, double dMin, double dMax) {
            if (dMin > dMax) throw ArgumentException("min cannot be greater than max.");
            if (dValue < dMin) return dMin;
            if (dValue > dMax) return dMax;
            return dValue;
        }
 
        int Math::Sign(int iValue) {
            if (iValue > 0) return 1;
            if (iValue < 0) return -1;
            return 0;
        }
 
        int Math::Sign(long long llValue) {
            if (llValue > 0) return 1;
            if (llValue < 0) return -1;
            return 0;
        }
 
        int Math::Sign(double dValue) {
            if (dValue > 0.0) return 1;
            if (dValue < 0.0) return -1;
            return 0;
        }
 
        double Math::Floor(double dValue) {
            return std::floor(dValue);
        }
 
        double Math::Ceiling(double dValue) {
            return std::ceil(dValue);
        }
 
        double Math::Round(double dValue) {
            return std::round(dValue);
        }
 
        double Math::Round(double dValue, int iDigits) {
            if (iDigits < 0 || iDigits > 15) throw ArgumentOutOfRangeException("Digits must be between 0 and 15.");
            double dFactor = std::pow(10.0, iDigits);
            return std::round(dValue * dFactor) / dFactor;
        }
 
        double Math::Truncate(double dValue) {
            return std::trunc(dValue);
        }
 
        double Math::Sqrt(double dValue) {
            return std::sqrt(dValue);
        }
 
        double Math::Cbrt(double dValue) {
            return std::cbrt(dValue);
        }
 
        double Math::Pow(double dBase, double dExponent) {
            return std::pow(dBase, dExponent);
        }
 
        double Math::Exp(double dValue) {
            return std::exp(dValue);
        }
 
        double Math::Log(double dValue) {
            return std::log(dValue);
        }
 
        double Math::Log(double dValue, double dNewBase) {
            if (dNewBase <= 0.0 || dNewBase == 1.0) throw ArgumentException("Base must be positive and not equal to 1.");
            return std::log(dValue) / std::log(dNewBase);
        }
 
        double Math::Log10(double dValue) {
            return std::log10(dValue);
        }
 
        double Math::Log2(double dValue) {
            return std::log2(dValue);
        }
 
        double Math::Sin(double dValue) {
            return std::sin(dValue);
        }
 
        double Math::Cos(double dValue) {
            return std::cos(dValue);
        }
 
        double Math::Tan(double dValue) {
            return std::tan(dValue);
        }
 
        double Math::Asin(double dValue) {
            return std::asin(dValue);
        }
 
        double Math::Acos(double dValue) {
            return std::acos(dValue);
        }
 
        double Math::Atan(double dValue) {
            return std::atan(dValue);
        }
 
        double Math::Atan2(double dY, double dX) {
            return std::atan2(dY, dX);
        }
 
        double Math::Sinh(double dValue) {
            return std::sinh(dValue);
        }
 
        double Math::Cosh(double dValue) {
            return std::cosh(dValue);
        }
 
        double Math::Tanh(double dValue) {
            return std::tanh(dValue);
        }
 
    }
}