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 <iomanip>
#include <numbers>
#include <random>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
 
#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_