irsmath.h

//! \file
//! \ingroup math_group
//! \brief Ìàòåìàòè÷åñêèå ôóíêöèè
//!
//! Äàòà: 18.05.2010
//! Ðàííÿÿ äàòà: 16.09.2009

#ifndef irsmathH
#define irsmathH

#include <irsdefs.h>

#include <irsstd.h>
#include <math.h>
#include <irscpp.h>

#include <irsfinal.h>

namespace irs {

//! \addtogroup math_group
//! @{

// a < b
const int less_than_value = -1;
// a == b
const int equals_value = 0;
// a > b
const int greater_than_value = 1;
// Ñðàâíèâàåò äâà çíà÷åíèÿ ñ òî÷íîñòüþ äî a_epsilon
// Àíàëîã ôóíêöèè CompareValue èç áèáëèîòåêè Math.hpp C++ Builder6
int compare_value(
  const double& a_a, const double& a_b, const double& a_epsilon);

// Îáðàòíûé ãèïåðáîëè÷åñêèé ñèíóñ
inline double asinh(const double a_x);
// Îáðàòíûé ãèïåðáîëè÷åñêèé êîñèíóñ, a_x >= 1
inline double acosh(const double a_x);
// Îáðàòíûé ãèïåðáîëè÷åñêèé òàíãåíñ
inline double atanh(const double a_x);

// Ãðàäóñû â ðàäèàíû
inline double deg_to_rad(const double a_degree);
// Ãðàäû â ðàäèàíû
inline double gra_to_rad(const double a_grad);
// Ðàäèàíû â ãðàäóñû
inline double rad_to_deg(const double a_radian);
// Ðàäèàíû â ãðàäû
inline double rad_to_gra(const double a_radian);

inline double sin_deg(const double a_degree);
inline double sin_rad(const double a_radian);
inline double sin_gra(const double a_grad);

inline double cos_deg(const double a_degree);
inline double cos_rad(const double a_radian);
inline double cos_gra(const double a_grad);

inline double tan_deg(const double a_degree);
inline double tan_rad(const double a_radian);
inline double tan_gra(const double a_grad);

inline double asin_deg(const double a_value);
inline double asin_rad(const double a_value);
inline double asin_gra(const double a_value);

inline double acos_deg(const double a_value);
inline double acos_rad(const double a_value);
inline double acos_gra(const double a_value);

inline double atan_deg(const double a_value);
inline double atan_rad(const double a_value);
inline double atan_gra(const double a_value);

// Ôóíêöèÿ ðåàëèçóåò àëãîðèòì Åâêëèäà -
// àëãîðèòì äëÿ íàõîæäåíèÿ íàèáîëüøåãî äåëèòåëÿ äâóõ
// öåëûõ ÷èñåë èëè íàèáîëüøåé îáùåé ìåðû äâóõ îäíîðîäíûõ âåëè÷èí.
inline int gcd(int a, int b);

// Íàõîæäåíèÿ íàèìåíüøåãî îáùåãî êðàòíîãî
inline int lcm(int a, int b);

inline double asinh(const double a_x)
{
  return log(a_x + sqrt(pow(a_x, 2.) + 1));
}

inline double acosh(const double a_x)
{
  return log(a_x + sqrt(pow(a_x, 2.) - 1));
}

inline double atanh(const double a_x)
{
  return 0.5 * log((1 + a_x) / (1 - a_x));
}

inline double deg_to_rad(const double a_degree)
{
  const double const_pi_180 = IRS_PI / 180;
  return a_degree * const_pi_180;
}

inline double gra_to_rad(const double a_grad)
{
  const double const_pi_200 = IRS_PI / 200;
  return a_grad * const_pi_200;
}

inline double rad_to_deg(const double a_radian)
{
  const double const_180_pi = 180 / IRS_PI;
  return a_radian * const_180_pi;
}

inline double rad_to_gra(const double a_radian)
{
  const double const_200_pi = 200 / IRS_PI;
  return a_radian * const_200_pi;
}         

inline double sin_deg(const double a_degree)
{
  double rad = deg_to_rad(a_degree);
  return sin(rad);
}

inline double sin_rad(const double a_radian)
{
  return sin(a_radian);
}

inline double sin_gra(const double a_grad)
{
  double rad = gra_to_rad(a_grad);
  return sin(rad);
}

inline double cos_deg(const double a_degree)
{
  double rad = deg_to_rad(a_degree);
  return cos(rad);
}

inline double cos_rad(const double a_radian)
{
  return cos(a_radian);
}

inline double cos_gra(const double a_grad)
{
  double rad = gra_to_rad(a_grad);
  return cos(rad);
}

inline double tan_deg(const double a_degree)
{
  double rad = deg_to_rad(a_degree);
  return tan(rad);
}

inline double tan_rad(const double a_radian)
{
  return tan(a_radian);
}

inline double tan_gra(const double a_grad)
{
  double rad = gra_to_rad(a_grad);
  return tan(rad);
}

inline double asin_deg(const double a_value)
{
  double radian = asin(a_value);
  return rad_to_deg(radian);
}

inline double asin_rad(const double a_value)
{
  return asin(a_value);
}

inline double asin_gra(const double a_value)
{
  double radian = asin(a_value);
  return rad_to_gra(radian);
}

inline double acos_deg(const double a_value)
{
  double radian = acos(a_value);
  return rad_to_deg(radian);
}

inline double acos_rad(const double a_value)
{
  return acos(a_value);
}

inline double acos_gra(const double a_value)
{
  double radian = acos(a_value);
  return rad_to_gra(radian);
}

inline double atan_deg(const double a_value)
{
  double radian = atan(a_value);
  return rad_to_deg(radian);
}

inline double atan_rad(const double a_value)
{
  return atan(a_value);
}

inline double atan_gra(const double a_value)
{
  double radian = atan(a_value);
  return rad_to_gra(radian);
}

inline int gcd(int a, int b)
{
  int c;
  while (b) {
    c = a % b;
    a = b;
    b = c;
  }
  return abs(a);
}

inline int lcm(int a, int b)
{
  return (a * b) / gcd(a, b);
}

//! @}

} // namespace irs
//---------------------------------------------------------------------------
#endif //irsmathH