math_util.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_MATH_UTIL_H_
#define DESIGNLAB_MATH_UTIL_H_
 
#include <concepts>
#include <numbers>
#include <random>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
#include <iomanip>
 
#include "cassert_define.h"
#include "math_const.h"
 
 
 
namespace designlab::math_util
{
 
template <typename T> concept Arithmetic = std::is_arithmetic_v<T>;
 
template <::std::floating_point T>
constexpr bool IsEqual(const T num1, const T num2) noexcept
{
    const T dif = num1 - num2;
 
    return (dif <= MathConst<T>::kAllowableError && dif >= -MathConst<T>::kAllowableError);
}
 
 
template <Arithmetic T>
constexpr T Squared(const T num) noexcept { return num * num; }
 
 
template <Arithmetic T>
constexpr bool CanMakeTriangle(const T a, const T b, const T c) noexcept
{
    assert(a >= 0);
    assert(b >= 0);
    assert(c >= 0);
    return (a + b > c && b + c > a && c + a > b);
}
 
 
template <typename T>
T ApproachTarget(const T& current, const T& target, float rate)
{
    assert(0 <= rate);
    assert(rate <= 1);  // 0 <= rate <= 1 でなければならない．
 
    if (current == target) { return current; }
 
    return static_cast<T>(current * (1 - rate) + target * rate);
}
 
 
template <Arithmetic T>
T GenerateRandomNumber(T min, T max)
{
    assert(min < max);  // min < max でなければならない．
 
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(min, max);
    return (T)dis(gen);
}
 
 
template <::std::floating_point T>
constexpr T ConvertRadToDeg(const T rad) noexcept
{
    return rad * (MathConst<T>::kRoundAngle / static_cast<T>(2)) / std::numbers::pi_v<float>;
}
 
template <::std::floating_point T>
constexpr T ConvertDegToRad(const T deg) noexcept
{
    return deg * std::numbers::pi_v<float> / (MathConst<T>::kRoundAngle / static_cast<T>(2));
}
 
template <::std::floating_point T>
T LimitRangeAngleDeg(T angle)
{
    angle = fmod(angle + MathConst<T>::kRoundAngle / 2, MathConst<T>::kRoundAngle);
 
    if (angle < 0.0)
    {
        angle += MathConst<T>::kRoundAngle;
    }
 
    return angle - MathConst<T>::kRoundAngle / 2;
}
 
 
constexpr int kDigit = 3;   
constexpr int kWidth = 10;  
 
template <::std::floating_point T>
std::string FloatingPointNumToString(
    const T num, const int digit = kDigit, const int width = kWidth)
{
    std::ostringstream ss;
 
    ss << std::fixed << std::setprecision(digit);
    ss << std::setw(width) << std::setfill(' ') << num;
 
    return ss.str();
}
 
 
}  // namespace designlab::math_util
 
 
#endif  // DESIGNLAB_MATH_UTIL_H_