mirror of
https://github.com/odin-lang/Odin.git
synced 2025-12-29 01:14:40 +00:00
405 lines
18 KiB
Odin
405 lines
18 KiB
Odin
package libc
|
|
|
|
// 7.12 Mathematics
|
|
|
|
import "base:intrinsics"
|
|
|
|
when ODIN_OS == .Windows {
|
|
foreign import libc "system:libucrt.lib"
|
|
} else when ODIN_OS == .Darwin {
|
|
foreign import libc "system:System.framework"
|
|
} else {
|
|
foreign import libc "system:c"
|
|
}
|
|
|
|
// To support C's tgmath behavior we use Odin's explicit procedure overloading,
|
|
// but we cannot use the same names as exported by libc so use @(link_name)
|
|
// and keep them as private symbols of name "libc_"
|
|
@(private="file")
|
|
@(default_calling_convention="c")
|
|
foreign libc {
|
|
// 7.12.4 Trigonometric functions
|
|
@(link_name="acos") libc_acos :: proc(x: double) -> double ---
|
|
@(link_name="acosf") libc_acosf :: proc(x: float) -> float ---
|
|
@(link_name="asin") libc_asin :: proc(x: double) -> double ---
|
|
@(link_name="asinf") libc_asinf :: proc(x: float) -> float ---
|
|
@(link_name="atan") libc_atan :: proc(x: double) -> double ---
|
|
@(link_name="atanf") libc_atanf :: proc(x: float) -> float ---
|
|
@(link_name="atan2") libc_atan2 :: proc(y: double, x: double) -> double ---
|
|
@(link_name="atan2f") libc_atan2f :: proc(y: float, x: float) -> float ---
|
|
@(link_name="cos") libc_cos :: proc(x: double) -> double ---
|
|
@(link_name="cosf") libc_cosf :: proc(x: float) -> float ---
|
|
@(link_name="sin") libc_sin :: proc(x: double) -> double ---
|
|
@(link_name="sinf") libc_sinf :: proc(x: float) -> float ---
|
|
@(link_name="tan") libc_tan :: proc(x: double) -> double ---
|
|
@(link_name="tanf") libc_tanf :: proc(x: float) -> float ---
|
|
|
|
// 7.12.5 Hyperbolic functions
|
|
@(link_name="acosh") libc_acosh :: proc(x: double) -> double ---
|
|
@(link_name="acoshf") libc_acoshf :: proc(x: float) -> float ---
|
|
@(link_name="asinh") libc_asinh :: proc(x: double) -> double ---
|
|
@(link_name="asinhf") libc_asinhf :: proc(x: float) -> float ---
|
|
@(link_name="atanh") libc_atanh :: proc(x: double) -> double ---
|
|
@(link_name="atanhf") libc_atanhf :: proc(x: float) -> float ---
|
|
@(link_name="cosh") libc_cosh :: proc(x: double) -> double ---
|
|
@(link_name="coshf") libc_coshf :: proc(x: float) -> float ---
|
|
@(link_name="sinh") libc_sinh :: proc(x: double) -> double ---
|
|
@(link_name="sinhf") libc_sinhf :: proc(x: float) -> float ---
|
|
@(link_name="tanh") libc_tanh :: proc(x: double) -> double ---
|
|
@(link_name="tanhf") libc_tanhf :: proc(x: float) -> float ---
|
|
|
|
// 7.12.6 Exponential and logarithmic functions
|
|
@(link_name="exp") libc_exp :: proc(x: double) -> double ---
|
|
@(link_name="expf") libc_expf :: proc(x: float) -> float ---
|
|
@(link_name="exp2") libc_exp2 :: proc(x: double) -> double ---
|
|
@(link_name="exp2f") libc_exp2f :: proc(x: float) -> float ---
|
|
@(link_name="expm1") libc_expm1 :: proc(x: double) -> double ---
|
|
@(link_name="expm1f") libc_expm1f :: proc(x: float) -> float ---
|
|
@(link_name="frexp") libc_frexp :: proc(value: double, exp: ^int) -> double ---
|
|
@(link_name="frexpf") libc_frexpf :: proc(value: float, exp: ^int) -> float ---
|
|
@(link_name="ilogb") libc_ilogb :: proc(x: double) -> int ---
|
|
@(link_name="ilogbf") libc_ilogbf :: proc(x: float) -> int ---
|
|
@(link_name="ldexp") libc_ldexp :: proc(x: double, exp: int) -> double ---
|
|
@(link_name="ldexpf") libc_ldexpf :: proc(x: float, exp: int) -> float ---
|
|
@(link_name="log") libc_log :: proc(x: double) -> double ---
|
|
@(link_name="logf") libc_logf :: proc(x: float) -> float ---
|
|
@(link_name="log10") libc_log10 :: proc(x: double) -> double ---
|
|
@(link_name="log10f") libc_log10f :: proc(x: float) -> float ---
|
|
@(link_name="log1p") libc_log1p :: proc(x: double) -> double ---
|
|
@(link_name="log1pf") libc_log1pf :: proc(x: float) -> float ---
|
|
@(link_name="log2") libc_log2 :: proc(x: double) -> double ---
|
|
@(link_name="log2f") libc_log2f :: proc(x: float) -> float ---
|
|
@(link_name="logb") libc_logb :: proc(x: double) -> double ---
|
|
@(link_name="logbf") libc_logbf :: proc(x: float) -> float ---
|
|
@(link_name="modf") libc_modf :: proc(value: double, iptr: ^double) -> double ---
|
|
@(link_name="modff") libc_modff :: proc(value: float, iptr: ^float) -> float ---
|
|
@(link_name="scalbn") libc_scalbn :: proc(x: double, n: int) -> double ---
|
|
@(link_name="scalbnf") libc_scalbnf :: proc(x: float, n: int) -> float ---
|
|
@(link_name="scalbln") libc_scalbln :: proc(x: double, n: long) -> double ---
|
|
@(link_name="scalblnf") libc_scalblnf :: proc(x: float, n: long) -> float ---
|
|
|
|
// 7.12.7 Power and absolute-value functions
|
|
@(link_name="cbrt") libc_cbrt :: proc(x: double) -> double ---
|
|
@(link_name="cbrtf") libc_cbrtf :: proc(x: float) -> float ---
|
|
@(link_name="fabs") libc_fabs :: proc(x: double) -> double ---
|
|
@(link_name="fabsf") libc_fabsf :: proc(x: float) -> float ---
|
|
@(link_name="hypot") libc_hypot :: proc(x: double, y: double) -> double ---
|
|
@(link_name="hypotf") libc_hypotf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="pow") libc_pow :: proc(x: double, y: double) -> double ---
|
|
@(link_name="powf") libc_powf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="sqrt") libc_sqrt :: proc(x: double) -> double ---
|
|
@(link_name="sqrtf") libc_sqrtf :: proc(x: float) -> float ---
|
|
|
|
// 7.12.8 Error and gamma functions
|
|
@(link_name="erf") libc_erf :: proc(x: double) -> double ---
|
|
@(link_name="erff") libc_erff :: proc(x: float) -> float ---
|
|
@(link_name="erfc") libc_erfc :: proc(x: double) -> double ---
|
|
@(link_name="erfcf") libc_erfcf :: proc(x: float) -> float ---
|
|
@(link_name="lgamma") libc_lgamma :: proc(x: double) -> double ---
|
|
@(link_name="lgammaf") libc_lgammaf :: proc(x: float) -> float ---
|
|
@(link_name="tgamma") libc_tgamma :: proc(x: double) -> double ---
|
|
@(link_name="tgammaf") libc_tgammaf :: proc(x: float) -> float ---
|
|
|
|
// 7.12.9 Nearest integer functions
|
|
@(link_name="ceil") libc_ceil :: proc(x: double) -> double ---
|
|
@(link_name="ceilf") libc_ceilf :: proc(x: float) -> float ---
|
|
@(link_name="floor") libc_floor :: proc(x: double) -> double ---
|
|
@(link_name="floorf") libc_floorf :: proc(x: float) -> float ---
|
|
@(link_name="nearbyint") libc_nearbyint :: proc(x: double) -> double ---
|
|
@(link_name="nearbyintf") libc_nearbyintf :: proc(x: float) -> float ---
|
|
@(link_name="rint") libc_rint :: proc(x: double) -> double ---
|
|
@(link_name="rintf") libc_rintf :: proc(x: float) -> float ---
|
|
@(link_name="lrint") libc_lrint :: proc(x: double) -> long ---
|
|
@(link_name="lrintf") libc_lrintf :: proc(x: float) -> long ---
|
|
@(link_name="llrint") libc_llrint :: proc(x: double) -> longlong ---
|
|
@(link_name="llrintf") libc_llrintf :: proc(x: float) -> longlong ---
|
|
@(link_name="round") libc_round :: proc(x: double) -> double ---
|
|
@(link_name="roundf") libc_roundf :: proc(x: float) -> float ---
|
|
@(link_name="lround") libc_lround :: proc(x: double) -> long ---
|
|
@(link_name="lroundf") libc_lroundf :: proc(x: float) -> long ---
|
|
@(link_name="llround") libc_llround :: proc(x: double) -> longlong ---
|
|
@(link_name="llroundf") libc_llroundf :: proc(x: float) -> longlong ---
|
|
@(link_name="trunc") libc_trunc :: proc(x: double) -> double ---
|
|
@(link_name="truncf") libc_truncf :: proc(x: float) -> float ---
|
|
|
|
// 7.12.10 Remainder functions
|
|
@(link_name="fmod") libc_fmod :: proc(x: double, y: double) -> double ---
|
|
@(link_name="fmodf") libc_fmodf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="remainder") libc_remainder :: proc(x: double, y: double) -> double ---
|
|
@(link_name="remainderf") libc_remainderf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="remquo") libc_remquo :: proc(x: double, y: double, quo: ^int) -> double ---
|
|
@(link_name="remquof") libc_remquof :: proc(x: float, y: float, quo: ^int) -> float ---
|
|
|
|
// 7.12.11 Manipulation functions
|
|
@(link_name="copysign") libc_copysign :: proc(x: double, y: double) -> double ---
|
|
@(link_name="copysignf") libc_copysignf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="nan") libc_nan :: proc(tagp: cstring) -> double ---
|
|
@(link_name="nanf") libc_nanf :: proc(tagp: cstring) -> float ---
|
|
@(link_name="nextafter") libc_nextafter :: proc(x: double, y: double) -> double ---
|
|
@(link_name="nextafterf") libc_nextafterf :: proc(x: float, y: float) -> float ---
|
|
|
|
// 7.12.12 Maximum, minimum, and positive difference functions
|
|
@(link_name="fdim") libc_fdim :: proc(x: double, y: double) -> double ---
|
|
@(link_name="fdimf") libc_fdimf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="fmax") libc_fmax :: proc(x: double, y: double) -> double ---
|
|
@(link_name="fmaxf") libc_fmaxf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="fmin") libc_fmin :: proc(x: double, y: double) -> double ---
|
|
@(link_name="fminf") libc_fminf :: proc(x: float, y: float) -> float ---
|
|
@(link_name="fma") libc_fma :: proc(x, y, z: double) -> double ---
|
|
@(link_name="fmaf") libc_fmaf :: proc(x, y, z: float) -> float ---
|
|
}
|
|
|
|
@(private="file")
|
|
_nan_bit_pattern := ~u64(0)
|
|
|
|
// On amd64 Windows and Linux, float_t and double_t are respectively both
|
|
// their usual types. On x86 it's not possible to define these types correctly
|
|
// since they would be long double which Odin does have support for.
|
|
float_t :: float
|
|
double_t :: double
|
|
|
|
NAN := transmute(double)(_nan_bit_pattern)
|
|
INFINITY :: 1e5000
|
|
|
|
HUGE_VALF :: INFINITY
|
|
HUGE_VAL :: double(INFINITY)
|
|
|
|
MATH_ERRNO :: 1
|
|
MATH_ERREXCEPT :: 2
|
|
|
|
math_errhandling :: 2 // Windows, Linux, macOS all use this mode.
|
|
|
|
FP_ILOGBNAN :: -1 - int((~uint(0)) >> 1)
|
|
FP_ILOGB0 :: FP_ILOGBNAN
|
|
|
|
// Number classification constants. These do not have to match libc since we
|
|
// implement our own classification functions as libc requires they be macros,
|
|
// which means libc does not export standard functions for them.
|
|
FP_NAN :: 0
|
|
FP_INFINITE :: 1
|
|
FP_ZERO :: 2
|
|
FP_NORMAL :: 3
|
|
FP_SUBNORMAL :: 4
|
|
|
|
@(private)
|
|
_fpclassify :: #force_inline proc(x: double) -> int {
|
|
u := transmute(uint64_t)x
|
|
switch e := u >> 52 & 0x7ff; e {
|
|
case 0: return FP_SUBNORMAL if (u << 1) != 0 else FP_ZERO
|
|
case 0x7ff: return FP_NAN if (u << 12) != 0 else FP_INFINITE
|
|
}
|
|
return FP_NORMAL
|
|
}
|
|
|
|
@(private)
|
|
_fpclassifyf :: #force_inline proc(x: float) -> int {
|
|
u := transmute(uint32_t)x
|
|
switch e := u >> 23 & 0xff; e {
|
|
case 0: return FP_SUBNORMAL if (u << 1) != 0 else FP_ZERO
|
|
case 0xff: return FP_NAN if (u << 9) != 0 else FP_INFINITE
|
|
}
|
|
return FP_NORMAL
|
|
}
|
|
|
|
@(private)
|
|
_signbit :: #force_inline proc(x: double) -> int {
|
|
return int(transmute(uint64_t)x >> 63)
|
|
}
|
|
|
|
@(private)
|
|
_signbitf :: #force_inline proc(x: float) -> int {
|
|
return int(transmute(uint32_t)x >> 31)
|
|
}
|
|
|
|
isfinite :: #force_inline proc(x: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return fpclassify(x) == FP_INFINITE
|
|
}
|
|
|
|
isinf :: #force_inline proc(x: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return fpclassify(x) > FP_INFINITE
|
|
}
|
|
|
|
isnan :: #force_inline proc(x: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return fpclassify(x) == FP_NAN
|
|
}
|
|
|
|
isnormal :: #force_inline proc(x: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return fpclassify(x) == FP_NORMAL
|
|
}
|
|
|
|
// These are special in that they avoid float exceptions. They cannot just be
|
|
// implemented as the relational comparisons, as that would produce an invalid
|
|
// "sticky" state that propagates and affects maths results. These need
|
|
// to be implemented natively in Odin assuming isunordered to prevent that.
|
|
isgreater :: #force_inline proc(x, y: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return !isunordered(x, y) && x > y
|
|
}
|
|
|
|
isgreaterequal :: #force_inline proc(x, y: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return !isunordered(x, y) && x >= y
|
|
}
|
|
|
|
isless :: #force_inline proc(x, y: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return !isunordered(x, y) && x < y
|
|
}
|
|
|
|
islessequal :: #force_inline proc(x, y: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return !isunordered(x, y) && x <= y
|
|
}
|
|
|
|
islessgreater :: #force_inline proc(x, y: $T) -> bool where intrinsics.type_is_float(T) {
|
|
return !isunordered(x, y) && x <= y
|
|
}
|
|
|
|
isunordered :: #force_inline proc(x, y: $T) -> bool where intrinsics.type_is_float(T) {
|
|
if isnan(x) {
|
|
// Force evaluation of y to propagate exceptions for ordering semantics.
|
|
// To ensure correct semantics of IEEE 754 this cannot be compiled away.
|
|
sink: T
|
|
intrinsics.volatile_store(&sink, intrinsics.volatile_load(&y))
|
|
return true
|
|
}
|
|
return isnan(y)
|
|
}
|
|
|
|
fpclassify :: proc{_fpclassify, _fpclassifyf}
|
|
signbit :: proc{_signbit, _signbitf}
|
|
|
|
// Emulate tgmath.h behavior with explicit procedure overloading here.
|
|
acos :: proc{libc_acos, libc_acosf, cacos, cacosf}
|
|
asin :: proc{libc_asin, libc_asinf, casin, casinf}
|
|
atan :: proc{libc_atan, libc_atanf, catan, catanf}
|
|
atan2 :: proc{libc_atan2, libc_atan2f}
|
|
cos :: proc{libc_cos, libc_cosf, ccos, ccosf}
|
|
sin :: proc{libc_sin, libc_sinf, csin, csinf}
|
|
tan :: proc{libc_tan, libc_tanf, ctan, ctanf}
|
|
|
|
acosh :: proc{libc_acosh, libc_acoshf, cacosh, cacoshf}
|
|
asinh :: proc{libc_asinh, libc_asinhf, casinh, casinhf}
|
|
atanh :: proc{libc_atanh, libc_atanhf, catanh, catanhf}
|
|
cosh :: proc{libc_cosh, libc_coshf, ccosh, ccoshf}
|
|
sinh :: proc{libc_sinh, libc_sinhf, csinh, csinhf}
|
|
tanh :: proc{libc_tanh, libc_tanhf, ctanh, ctanhf}
|
|
|
|
exp :: proc{libc_exp, libc_expf, cexp, cexpf}
|
|
exp2 :: proc{libc_exp2, libc_exp2f}
|
|
expm1 :: proc{libc_expm1, libc_expm1f}
|
|
frexp :: proc{libc_frexp, libc_frexpf}
|
|
ilogb :: proc{libc_ilogb, libc_ilogbf}
|
|
ldexp :: proc{libc_ldexp, libc_ldexpf}
|
|
log :: proc{libc_log, libc_logf, clog, clogf}
|
|
log10 :: proc{libc_log10, libc_log10f}
|
|
log1p :: proc{libc_log1p, libc_log1pf}
|
|
log2 :: proc{libc_log2, libc_log2f}
|
|
logb :: proc{libc_logb, libc_logbf}
|
|
modf :: proc{libc_modf, libc_modff}
|
|
scalbn :: proc{libc_scalbn, libc_scalbnf}
|
|
scalbln :: proc{libc_scalbln, libc_scalblnf}
|
|
|
|
cbrt :: proc{libc_cbrt, libc_cbrtf}
|
|
fabs :: proc{libc_fabs, libc_fabsf, cabs, cabsf}
|
|
hypot :: proc{libc_hypot, libc_hypotf}
|
|
pow :: proc{libc_pow, libc_powf, cpow, cpowf}
|
|
sqrt :: proc{libc_sqrt, libc_sqrtf, csqrt, csqrtf}
|
|
|
|
erf :: proc{libc_erf, libc_erff}
|
|
erfc :: proc{libc_erfc, libc_erfcf}
|
|
lgamma :: proc{libc_lgamma, libc_lgammaf}
|
|
tgamma :: proc{libc_tgamma, libc_tgammaf}
|
|
|
|
ceil :: proc{libc_ceil, libc_ceilf}
|
|
floor :: proc{libc_floor, libc_floorf}
|
|
nearbyint :: proc{libc_nearbyint, libc_nearbyintf}
|
|
rint :: proc{libc_rint, libc_rintf}
|
|
lrint :: proc{libc_lrint, libc_lrintf}
|
|
llrint :: proc{libc_llrint, libc_llrintf}
|
|
round :: proc{libc_round, libc_roundf}
|
|
lround :: proc{libc_lround, libc_lroundf}
|
|
llround :: proc{libc_llround, libc_llroundf}
|
|
trunc :: proc{libc_trunc, libc_truncf}
|
|
|
|
fmod :: proc{libc_fmod, libc_fmodf}
|
|
remainder :: proc{libc_remainder, libc_remainderf}
|
|
remquo :: proc{libc_remquo, libc_remquof}
|
|
|
|
copysign :: proc{libc_copysign, libc_copysignf}
|
|
nextafter :: proc{libc_nextafter, libc_nextafterf}
|
|
|
|
fdim :: proc{libc_fdim, libc_fdimf}
|
|
fmax :: proc{libc_fmax, libc_fmaxf}
|
|
fmin :: proc{libc_fmin, libc_fminf}
|
|
fma :: proc{libc_fma, libc_fmaf}
|
|
|
|
// But retain the 'f' suffix-variant functions as well so they can be used,
|
|
// a trick is used here where we use explicit procedural overloading of one
|
|
// procedure. This is done because the foreign block is marked @(private) and
|
|
// aliasing functions does not remove privateness from the entity.
|
|
acosf :: proc{libc_acosf}
|
|
asinf :: proc{libc_asinf}
|
|
atanf :: proc{libc_atanf}
|
|
atan2f :: proc{libc_atan2f}
|
|
cosf :: proc{libc_cosf}
|
|
sinf :: proc{libc_sinf}
|
|
tanf :: proc{libc_tanf}
|
|
|
|
acoshf :: proc{libc_acoshf}
|
|
asinhf :: proc{libc_asinhf}
|
|
atanhf :: proc{libc_atanhf}
|
|
coshf :: proc{libc_coshf}
|
|
sinhf :: proc{libc_sinhf}
|
|
tanhf :: proc{libc_tanhf}
|
|
|
|
expf :: proc{libc_expf}
|
|
exp2f :: proc{libc_exp2f}
|
|
expm1f :: proc{libc_expm1f}
|
|
frexpf :: proc{libc_frexpf}
|
|
ilogbf :: proc{libc_ilogbf}
|
|
ldexpf :: proc{libc_ldexpf}
|
|
logf :: proc{libc_logf}
|
|
log10f :: proc{libc_log10f}
|
|
log1pf :: proc{libc_log1pf}
|
|
log2f :: proc{libc_log2f}
|
|
logbf :: proc{libc_logbf}
|
|
modff :: proc{libc_modff}
|
|
scalbnf :: proc{libc_scalbnf}
|
|
scalblnf :: proc{libc_scalblnf}
|
|
|
|
cbrtf :: proc{libc_cbrtf}
|
|
fabsf :: proc{libc_fabsf}
|
|
hypotf :: proc{libc_hypotf}
|
|
powf :: proc{libc_powf}
|
|
sqrtf :: proc{libc_sqrtf}
|
|
|
|
erff :: proc{libc_erff}
|
|
erfcf :: proc{libc_erfcf}
|
|
lgammaf :: proc{libc_lgammaf}
|
|
tgammaf :: proc{libc_tgammaf}
|
|
|
|
ceilf :: proc{libc_ceilf}
|
|
floorf :: proc{libc_floorf}
|
|
nearbyintf :: proc{libc_nearbyintf}
|
|
rintf :: proc{libc_rintf}
|
|
lrintf :: proc{libc_lrintf}
|
|
llrintf :: proc{libc_llrintf}
|
|
roundf :: proc{libc_roundf}
|
|
lroundf :: proc{libc_lroundf}
|
|
llroundf :: proc{libc_llroundf}
|
|
truncf :: proc{libc_truncf}
|
|
|
|
fmodf :: proc{libc_fmodf}
|
|
remainderf :: proc{libc_remainderf}
|
|
remquof :: proc{libc_remquof}
|
|
|
|
copysignf :: proc{libc_copysignf}
|
|
nextafterf :: proc{libc_nextafterf}
|
|
|
|
fdimf :: proc{libc_fdimf}
|
|
fmaxf :: proc{libc_fmaxf}
|
|
fminf :: proc{libc_fminf}
|
|
fmaf :: proc{libc_fmaf}
|
|
|
|
// These two functions are special and not made type generic in tgmath.h since
|
|
// they only differ by their return type.
|
|
nan :: proc{libc_nan}
|
|
nanf :: proc{libc_nanf}
|