@shd101wyy/yo 0.0.2

package/std/libc/math.yo

@@ -0,0 +1,679 @@
+c_include "<math.h>",
+  // Mathematical constants (implementation-defined)
+  M_E : f64,           // e (2.71828...)
+  M_LOG2E : f64,       // log_2(e)
+  M_LOG10E : f64,      // log_10(e)
+  M_LN2 : f64,         // ln(2)
+  M_LN10 : f64,        // ln(10)
+  M_PI : f64,          // π (3.14159...)
+  M_PI_2 : f64,        // π/2
+  M_PI_4 : f64,        // π/4
+  M_1_PI : f64,        // 1/π
+  M_2_PI : f64,        // 2/π
+  M_2_SQRTPI : f64,    // 2/√π
+  M_SQRT2 : f64,       // √2
+  M_SQRT1_2 : f64,     // 1/√2
+
+  // Special values
+  HUGE_VAL : f64,
+  HUGE_VALF : f32,
+  HUGE_VALL : longdouble,
+  INFINITY : f32,
+  NAN : f32,
+
+  // Trigonometric functions
+  sin :
+    fn(x : f64) -> f64,
+  cos :
+    fn(x : f64) -> f64,
+  tan :
+    fn(x : f64) -> f64,
+  asin :
+    fn(x : f64) -> f64,
+  acos :
+    fn(x : f64) -> f64,
+  atan :
+    fn(x : f64) -> f64,
+  atan2 :
+    fn(y : f64, x : f64) -> f64,
+
+  // Hyperbolic functions
+  sinh :
+    fn(x : f64) -> f64,
+  cosh :
+    fn(x : f64) -> f64,
+  tanh :
+    fn(x : f64) -> f64,
+  asinh :
+    fn(x : f64) -> f64,
+  acosh :
+    fn(x : f64) -> f64,
+  atanh :
+    fn(x : f64) -> f64,
+
+  // Exponential and logarithmic functions
+  exp :
+    fn(x : f64) -> f64,
+  exp2 :
+    fn(x : f64) -> f64,
+  expm1 :
+    fn(x : f64) -> f64,    // exp(x) - 1
+  log :
+    fn(x : f64) -> f64,      // natural logarithm
+  log2 :
+    fn(x : f64) -> f64,
+  log10 :
+    fn(x : f64) -> f64,
+  log1p :
+    fn(x : f64) -> f64,    // log(1 + x)
+  logb :
+    fn(x : f64) -> f64,
+  ilogb :
+    fn(x : f64) -> int,
+
+  // Power functions
+  pow :
+    fn(x : f64, y : f64) -> f64,
+  sqrt :
+    fn(x : f64) -> f64,
+  cbrt :
+    fn(x : f64) -> f64,     // cube root
+  hypot :
+    fn(x : f64, y : f64) -> f64, // sqrt(x^2 + y^2)
+
+  // Error and gamma functions
+  erf :
+    fn(x : f64) -> f64,      // error function
+  erfc :
+    fn(x : f64) -> f64,     // complementary error function
+  gamma :
+    fn(x : f64) -> f64,    // gamma function
+  lgamma :
+    fn(x : f64) -> f64,   // log gamma function
+
+  // Nearest integer functions
+  ceil :
+    fn(x : f64) -> f64,
+  floor :
+    fn(x : f64) -> f64,
+  trunc :
+    fn(x : f64) -> f64,
+  round :
+    fn(x : f64) -> f64,
+  lround :
+    fn(x : f64) -> long,
+  llround :
+    fn(x : f64) -> longlong,
+  rint :
+    fn(x : f64) -> f64,
+  lrint :
+    fn(x : f64) -> long,
+  llrint :
+    fn(x : f64) -> longlong,
+  nearbyint :
+    fn(x : f64) -> f64,
+
+  // Floating point manipulation functions
+  frexp :
+    fn(value : f64, exp : *(int)) -> f64,
+  ldexp :
+    fn(x : f64, exp : int) -> f64,
+  modf :
+    fn(value : f64, iptr : *(f64)) -> f64,
+  scalbn :
+    fn(x : f64, n : int) -> f64,
+  scalbln :
+    fn(x : f64, n : long) -> f64,
+
+  // Absolute value and remainder functions
+  fabs :
+    fn(x : f64) -> f64,
+  fmod :
+    fn(x : f64, y : f64) -> f64,
+  remainder :
+    fn(x : f64, y : f64) -> f64,
+  remquo :
+    fn(x : f64, y : f64, quo : *(int)) -> f64,
+
+  // Copying sign functions
+  copysign :
+    fn(x : f64, y : f64) -> f64,
+  nan :
+    fn(tagp : *(char)) -> f64,
+  nanf :
+    fn(tagp : *(char)) -> f32,
+  nanl :
+    fn(tagp : *(char)) -> longdouble,
+
+  // Maximum, minimum, and positive difference functions
+  fdim :
+    fn(x : f64, y : f64) -> f64,  // positive difference
+  fmax :
+    fn(x : f64, y : f64) -> f64,
+  fmin :
+    fn(x : f64, y : f64) -> f64,
+
+  // Floating multiply-add
+  fma :
+    fn(x : f64, y : f64, z : f64) -> f64, // x*y + z
+
+  // Classification functions
+  fpclassify :
+    fn(x : f64) -> int,
+  isfinite :
+    fn(x : f64) -> int,
+  isinf :
+    fn(x : f64) -> int,
+  isnan :
+    fn(x : f64) -> int,
+  isnormal :
+    fn(x : f64) -> int,
+  signbit :
+    fn(x : f64) -> int,
+
+  // Comparison functions
+  isgreater :
+    fn(x : f64, y : f64) -> int,
+  isgreaterequal :
+    fn(x : f64, y : f64) -> int,
+  isless :
+    fn(x : f64, y : f64) -> int,
+  islessequal :
+    fn(x : f64, y : f64) -> int,
+  islessgreater :
+    fn(x : f64, y : f64) -> int,
+  isunordered :
+    fn(x : f64, y : f64) -> int,
+
+  // Float versions of functions
+  sinf :
+    fn(x : f32) -> f32,
+  cosf :
+    fn(x : f32) -> f32,
+  tanf :
+    fn(x : f32) -> f32,
+  asinf :
+    fn(x : f32) -> f32,
+  acosf :
+    fn(x : f32) -> f32,
+  atanf :
+    fn(x : f32) -> f32,
+  atan2f :
+    fn(y : f32, x : f32) -> f32,
+  
+  sinhf :
+    fn(x : f32) -> f32,
+  coshf :
+    fn(x : f32) -> f32,
+  tanhf :
+    fn(x : f32) -> f32,
+  asinhf :
+    fn(x : f32) -> f32,
+  acoshf :
+    fn(x : f32) -> f32,
+  atanhf :
+    fn(x : f32) -> f32,
+  
+  expf :
+    fn(x : f32) -> f32,
+  exp2f :
+    fn(x : f32) -> f32,
+  expm1f :
+    fn(x : f32) -> f32,
+  logf :
+    fn(x : f32) -> f32,
+  log2f :
+    fn(x : f32) -> f32,
+  log10f :
+    fn(x : f32) -> f32,
+  log1pf :
+    fn(x : f32) -> f32,
+  logbf :
+    fn(x : f32) -> f32,
+  ilogbf :
+    fn(x : f32) -> int,
+  
+  powf :
+    fn(x : f32, y : f32) -> f32,
+  sqrtf :
+    fn(x : f32) -> f32,
+  cbrtf :
+    fn(x : f32) -> f32,
+  hypotf :
+    fn(x : f32, y : f32) -> f32,
+  
+  erff :
+    fn(x : f32) -> f32,
+  erfcf :
+    fn(x : f32) -> f32,
+  gammaf :
+    fn(x : f32) -> f32,
+  lgammaf :
+    fn(x : f32) -> f32,
+  
+  ceilf :
+    fn(x : f32) -> f32,
+  floorf :
+    fn(x : f32) -> f32,
+  truncf :
+    fn(x : f32) -> f32,
+  roundf :
+    fn(x : f32) -> f32,
+  lroundf :
+    fn(x : f32) -> long,
+  llroundf :
+    fn(x : f32) -> longlong,
+  rintf :
+    fn(x : f32) -> f32,
+  lrintf :
+    fn(x : f32) -> long,
+  llrintf :
+    fn(x : f32) -> longlong,
+  nearbyintf :
+    fn(x : f32) -> f32,
+  
+  frexpf :
+    fn(value : f32, exp : *(int)) -> f32,
+  ldexpf :
+    fn(x : f32, exp : int) -> f32,
+  modff :
+    fn(value : f32, iptr : *(f32)) -> f32,
+  scalbnf :
+    fn(x : f32, n : int) -> f32,
+  scalblnf :
+    fn(x : f32, n : long) -> f32,
+  
+  fabsf :
+    fn(x : f32) -> f32,
+  fmodf :
+    fn(x : f32, y : f32) -> f32,
+  remainderf :
+    fn(x : f32, y : f32) -> f32,
+  remquof :
+    fn(x : f32, y : f32, quo : *(int)) -> f32,
+  
+  copysignf :
+    fn(x : f32, y : f32) -> f32,
+  fdimf :
+    fn(x : f32, y : f32) -> f32,
+  fmaxf :
+    fn(x : f32, y : f32) -> f32,
+  fminf :
+    fn(x : f32, y : f32) -> f32,
+  fmaf :
+    fn(x : f32, y : f32, z : f32) -> f32,
+
+  // Long f64 versions of functions
+  sinl :
+    fn(x : longdouble) -> longdouble,
+  cosl :
+    fn(x : longdouble) -> longdouble,
+  tanl :
+    fn(x : longdouble) -> longdouble,
+  asinl :
+    fn(x : longdouble) -> longdouble,
+  acosl :
+    fn(x : longdouble) -> longdouble,
+  atanl :
+    fn(x : longdouble) -> longdouble,
+  atan2l :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  
+  sinhl :
+    fn(x : longdouble) -> longdouble,
+  coshl :
+    fn(x : longdouble) -> longdouble,
+  tanhl :
+    fn(x : longdouble) -> longdouble,
+  asinhl :
+    fn(x : longdouble) -> longdouble,
+  acoshl :
+    fn(x : longdouble) -> longdouble,
+  atanhl :
+    fn(x : longdouble) -> longdouble,
+  
+  expl :
+    fn(x : longdouble) -> longdouble,
+  exp2l :
+    fn(x : longdouble) -> longdouble,
+  expm1l :
+    fn(x : longdouble) -> longdouble,
+  logl :
+    fn(x : longdouble) -> longdouble,
+  log2l :
+    fn(x : longdouble) -> longdouble,
+  log10l :
+    fn(x : longdouble) -> longdouble,
+  log1pl :
+    fn(x : longdouble) -> longdouble,
+  logbl :
+    fn(x : longdouble) -> longdouble,
+  ilogbl :
+    fn(x : longdouble) -> int,
+  
+  powl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  sqrtl :
+    fn(x : longdouble) -> longdouble,
+  cbrtl :
+    fn(x : longdouble) -> longdouble,
+  hypotl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  
+  erfl :
+    fn(x : longdouble) -> longdouble,
+  erfcl :
+    fn(x : longdouble) -> longdouble,
+  gammal :
+    fn(x : longdouble) -> longdouble,
+  lgammal :
+    fn(x : longdouble) -> longdouble,
+  
+  ceill :
+    fn(x : longdouble) -> longdouble,
+  floorl :
+    fn(x : longdouble) -> longdouble,
+  truncl :
+    fn(x : longdouble) -> longdouble,
+  roundl :
+    fn(x : longdouble) -> longdouble,
+  lroundl :
+    fn(x : longdouble) -> long,
+  llroundl :
+    fn(x : longdouble) -> longlong,
+  rintl :
+    fn(x : longdouble) -> longdouble,
+  lrintl :
+    fn(x : longdouble) -> long,
+  llrintl :
+    fn(x : longdouble) -> longlong,
+  nearbyintl :
+    fn(x : longdouble) -> longdouble,
+  
+  frexpl :
+    fn(value : longdouble, exp : *(int)) -> longdouble,
+  ldexpl :
+    fn(x : longdouble, exp : int) -> longdouble,
+  modfl :
+    fn(value : longdouble, iptr : *(longdouble)) -> longdouble,
+  scalbnl :
+    fn(x : longdouble, n : int) -> longdouble,
+  scalblnl :
+    fn(x : longdouble, n : long) -> longdouble,
+  
+  fabsl :
+    fn(x : longdouble) -> longdouble,
+  fmodl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  remainderl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  remquol :
+    fn(x : longdouble, y : longdouble, quo : *(int)) -> longdouble,
+  
+  copysignl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  fdiml :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  fmaxl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  fminl :
+    fn(x : longdouble, y : longdouble) -> longdouble,
+  fmal :
+    fn(x : longdouble, y : longdouble, z : longdouble) -> longdouble,
+
+  // Classification constants
+  FP_INFINITE : int,
+  FP_NAN : int,
+  FP_NORMAL : int,
+  FP_SUBNORMAL : int,
+  FP_ZERO : int,
+
+  // Math error handling
+  math_errhandling : int,
+  MATH_ERRNO : int,
+  MATH_ERREXCEPT : int
+;
+
+// Export all math functionality
+export 
+  // Mathematical constants
+  M_E,
+  M_LOG2E,
+  M_LOG10E,
+  M_LN2,
+  M_LN10,
+  M_PI,
+  M_PI_2,
+  M_PI_4,
+  M_1_PI,
+  M_2_PI,
+  M_2_SQRTPI,
+  M_SQRT2,
+  M_SQRT1_2,
+
+  // Special values
+  HUGE_VAL,
+  HUGE_VALF,
+  HUGE_VALL,
+  INFINITY,
+  NAN,
+
+  // Trigonometric functions
+  sin,
+  cos,
+  tan,
+  asin,
+  acos,
+  atan,
+  atan2,
+
+  // Hyperbolic functions
+  sinh,
+  cosh,
+  tanh,
+  asinh,
+  acosh,
+  atanh,
+
+  // Exponential and logarithmic functions
+  exp,
+  exp2,
+  expm1,
+  log,
+  log2,
+  log10,
+  log1p,
+  logb,
+  ilogb,
+
+  // Power functions
+  pow,
+  sqrt,
+  cbrt,
+  hypot,
+
+  // Error and gamma functions
+  erf,
+  erfc,
+  gamma,
+  lgamma,
+
+  // Nearest integer functions
+  ceil,
+  floor,
+  trunc,
+  round,
+  lround,
+  llround,
+  rint,
+  lrint,
+  llrint,
+  nearbyint,
+
+  // Floating point manipulation functions
+  frexp,
+  ldexp,
+  modf,
+  scalbn,
+  scalbln,
+
+  // Absolute value and remainder functions
+  fabs,
+  fmod,
+  remainder,
+  remquo,
+
+  // Copying sign functions
+  copysign,
+  nan,
+  nanf,
+  nanl,
+
+  // Maximum, minimum, and positive difference functions
+  fdim,
+  fmax,
+  fmin,
+
+  // Floating multiply-add
+  fma,
+
+  // Classification functions
+  fpclassify,
+  isfinite,
+  isinf,
+  isnan,
+  isnormal,
+  signbit,
+
+  // Comparison functions
+  isgreater,
+  isgreaterequal,
+  isless,
+  islessequal,
+  islessgreater,
+  isunordered,
+
+  // Float versions
+  sinf,
+  cosf,
+  tanf,
+  asinf,
+  acosf,
+  atanf,
+  atan2f,
+  sinhf,
+  coshf,
+  tanhf,
+  asinhf,
+  acoshf,
+  atanhf,
+  expf,
+  exp2f,
+  expm1f,
+  logf,
+  log2f,
+  log10f,
+  log1pf,
+  logbf,
+  ilogbf,
+  powf,
+  sqrtf,
+  cbrtf,
+  hypotf,
+  erff,
+  erfcf,
+  gammaf,
+  lgammaf,
+  ceilf,
+  floorf,
+  truncf,
+  roundf,
+  lroundf,
+  llroundf,
+  rintf,
+  lrintf,
+  llrintf,
+  nearbyintf,
+  frexpf,
+  ldexpf,
+  modff,
+  scalbnf,
+  scalblnf,
+  fabsf,
+  fmodf,
+  remainderf,
+  remquof,
+  copysignf,
+  fdimf,
+  fmaxf,
+  fminf,
+  fmaf,
+
+  // Long f64 versions
+  sinl,
+  cosl,
+  tanl,
+  asinl,
+  acosl,
+  atanl,
+  atan2l,
+  sinhl,
+  coshl,
+  tanhl,
+  asinhl,
+  acoshl,
+  atanhl,
+  expl,
+  exp2l,
+  expm1l,
+  logl,
+  log2l,
+  log10l,
+  log1pl,
+  logbl,
+  ilogbl,
+  powl,
+  sqrtl,
+  cbrtl,
+  hypotl,
+  erfl,
+  erfcl,
+  gammal,
+  lgammal,
+  ceill,
+  floorl,
+  truncl,
+  roundl,
+  lroundl,
+  llroundl,
+  rintl,
+  lrintl,
+  llrintl,
+  nearbyintl,
+  frexpl,
+  ldexpl,
+  modfl,
+  scalbnl,
+  scalblnl,
+  fabsl,
+  fmodl,
+  remainderl,
+  remquol,
+  copysignl,
+  fdiml,
+  fmaxl,
+  fminl,
+  fmal,
+
+  // Classification constants
+  FP_INFINITE,
+  FP_NAN,
+  FP_NORMAL,
+  FP_SUBNORMAL,
+  FP_ZERO,
+
+  // Math error handling
+  math_errhandling,
+  MATH_ERRNO,
+  MATH_ERREXCEPT
+;