#ifndef VLIBC_MATH_H
#define VLIBC_MATH_H

/*
 * vlibc — <math.h>.
 *
 * This header is ISO C core and is present in every profile. It carries the
 * whole todo-39 arithmetic inventory: the classification macros
 * (fpclassify/isnan/isinf/isfinite/isnormal/signbit), the constants
 * (HUGE_VAL/INFINITY/NAN, FP_*, math_errhandling), and the 25 basic
 * real-function families (fabs, copysign, floor, ceil, trunc, round, rint,
 * nearbyint, lrint, llrint, frexp, ldexp, modf, scalbn, scalbln, fmin,
 * fmax, fdim, fmod, remainder, remquo, ilogb, logb, lround, llround), each
 * spelled in all three precisions (float `...f`, double, long double
 * `...l`).
 *
 * Every declaration below lands NOW so that the header is stable across the
 * todo-39 implementation slices; the slices (wip commits) fill in the
 * src/math/ definitions family by family and never touch this header again.
 * Later math todos extend this header in place the same way stdlib.h is
 * extended: todo 40 adds the exp/log/pow families, todo 41 the trig and
 * hyperbolic families, todo 42 erf/erfc/lgamma/tgamma/fma/nextafter/nan,
 * and todo 43 provides <complex.h> separately.
 *
 * Edge-case behavior (IEEE 754-2008): floor/ceil/trunc round exact results
 * with correct signed-zero and NaN/Inf handling; fabs/copysign/fmin/fmax/
 * fdim never raise an exception on their own and preserve NaN payloads
 * where the standard allows; the classification macros are
 * exception-free. Functions that per POSIX can set errno (ldexp, scalbn,
 * scalbln, fmod, remainder, remquo, and the fraction-splitters frexp/modf
 * with their pointer outputs) carry no const attribute below so the
 * compiler never hoists or elides an errno-setting call. Functions that
 * are pure (never set errno in their defined domain — fabs, copysign,
 * floor, ceil, trunc, round, rint, nearbyint, fmin, fmax, fdim, ilogb,
 * logb) are declared const and fold away in static links.
 */

#include <vlibc/features.h>

#include <limits.h>
#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

/* ---- Constants ---- */

/*
 * Positive infinity, as double/float/long double (C23 7.12.1p4). HUGE_VAL
 * is also the "overflowed" return value of the strto* conversions.
 */
#define HUGE_VAL __builtin_huge_val()
#define HUGE_VALF __builtin_huge_valf()
#define HUGE_VALL __builtin_huge_vall()

/* Positive infinity as a float (C23 7.12.1p5). */
#define INFINITY __builtin_inff()

/* A quiet NaN as a float (C23 7.12.1p6); the payload is implementation
 * defined but always a NaN of the quiet kind. */
#define NAN __builtin_nanf("")

/*
 * Return values of fpclassify (C23 7.12.3.1): the numbers need only be
 * distinct positive values; the classification macros below hand these
 * exact constants to __builtin_fpclassify so the two always agree.
 */
#define FP_NAN 0
#define FP_INFINITE 1
#define FP_ZERO 2
#define FP_SUBNORMAL 3
#define FP_NORMAL 4

/*
 * Return values of ilogb (C23 7.12.6.5p4): FP_ILOGB0 for a zero argument
 * and FP_ILOGBNAN for a NaN or infinite argument, each the indicated
 * <limits.h> sentinel.
 */
#define FP_ILOGB0 INT_MIN
#define FP_ILOGBNAN INT_MAX

/*
 * Which error mechanisms the library reports through (C23 7.12.1p3):
 * MATH_ERRNO and MATH_ERREXCEPT are both in effect (the domain/range
 * errno values are set where POSIX requires and the corresponding
 * floating-point exceptions are raised by the hardware).
 */
#define MATH_ERRNO 1
#define MATH_ERREXCEPT 2
#define math_errhandling 3

/* ---- Classification macros (type-generic, exception-free) ---- */

/*
 * Classify x as NaN, infinite, zero, subnormal, or normal, returning the
 * matching FP_* constant. __builtin_fpclassify is a GCC type-generic
 * builtin that evaluates its floating argument exactly once and never
 * traps, so no _Generic dispatch is needed here.
 */
#define fpclassify(x)                                                                              \
    __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, (x))

/*
 * The predicate macros below are thin wrappers over the corresponding
 * GCC type-generic builtins. Each builtin evaluates its argument once and
 * returns an int; integer arguments classify as finite, non-zero, and
 * normal (they convert exactly), so isnan(3) is 0 and isinf(3) is 0.
 */
#define isnan(x) __builtin_isnan(x)
#define isinf(x) __builtin_isinf(x)
#define isfinite(x) __builtin_isfinite(x)
#define isnormal(x) __builtin_isnormal(x)
#define signbit(x) __builtin_signbit(x)

/* ---- Basic arithmetic families (todo 39) ---- */

/*
 * Absolute value of x (C23 7.12.7.2). fabs(±0) is +0, fabs(±Inf) is +Inf,
 * and fabs(NaN) is a NaN. Pure: no domain, no exception.
 */
__attribute__((const)) float
fabsf(float x);

__attribute__((const)) double
fabs(double x);

__attribute__((const)) long double
fabsl(long double x);

/*
 * A value with the magnitude of x and the sign of y (C23 7.12.7.3).
 * copysign(±0, y) carries y's sign; a NaN x keeps its payload but takes
 * y's sign bit. Pure.
 */
__attribute__((const)) float
copysignf(float x, float y);

__attribute__((const)) double
copysign(double x, double y);

__attribute__((const)) long double
copysignl(long double x, long double y);

/*
 * The largest integral value not greater than x (C23 7.12.9.2).
 * floor(±0) is ±0, floor(-0.5) is -1.0, floor(±Inf) and floor(NaN)
 * return their argument unchanged. Pure and exact (no inexact
 * exception), so it folds.
 */
__attribute__((const)) float
floorf(float x);

__attribute__((const)) double
floor(double x);

__attribute__((const)) long double
floorl(long double x);

/*
 * The smallest integral value not less than x (C23 7.12.9.1).
 * ceil(±0) is ±0, ceil(-0.5) is -0.0 (a real negative zero), ceil(±Inf)
 * and ceil(NaN) return their argument unchanged. Pure and exact.
 */
__attribute__((const)) float
ceilf(float x);

__attribute__((const)) double
ceil(double x);

__attribute__((const)) long double
ceill(long double x);

/*
 * The integral value nearest to x in the direction of zero (C23 7.12.9.3).
 * trunc(-0.7) is -0.0, trunc(0.7) is 0.0, and ±Inf/NaN pass through.
 * Pure and exact.
 */
__attribute__((const)) float
truncf(float x);

__attribute__((const)) double
trunc(double x);

__attribute__((const)) long double
truncl(long double x);

/*
 * The integral value nearest to x, with halfway cases rounded away from
 * zero (C23 7.12.9.6). round(±0) is ±0, round(-0.5) is -1.0, and ±Inf/
 * NaN pass through. Pure: round never raises the inexact exception.
 */
__attribute__((const)) float
roundf(float x);

__attribute__((const)) double
round(double x);

__attribute__((const)) long double
roundl(long double x);

/*
 * The integral value nearest to x in the current rounding direction
 * (C23 7.12.9.4). rint may raise the inexact exception; it is still pure
 * in the const sense because it never sets errno and reads no memory.
 */
__attribute__((const)) float
rintf(float x);

__attribute__((const)) double
rint(double x);

__attribute__((const)) long double
rintl(long double x);

/*
 * As rint, but guaranteed never to raise the inexact exception (C23
 * 7.12.9.5). Pure and exact.
 */
__attribute__((const)) float
nearbyintf(float x);

__attribute__((const)) double
nearbyint(double x);

__attribute__((const)) long double
nearbyintl(long double x);

/*
 * The nearest integral value to x in the current rounding direction,
 * returned as long (C23 7.12.9.7). A result outside the range of long is
 * a range error (the return value is unspecified and errno may be set),
 * so no const attribute.
 */
long
lrintf(float x);

long
lrint(double x);

long
lrintl(long double x);

/*
 * As lrint, returned as long long (C23 7.12.9.8). Range errors as for
 * lrint; no const attribute.
 */
long long
llrintf(float x);

long long
llrint(double x);

long long
llrintl(long double x);

/*
 * Split x into a fraction f in [1/2, 1) (or 0) and an integer exponent
 * *exp such that x == f * 2^(*exp) (C23 7.12.6.4). Zero returns ±0 with
 * *exp 0; Inf/NaN return x with an unspecified *exp. Writes *exp, so no
 * const attribute.
 */
float
frexpf(float x, int *exp);

double
frexp(double x, int *exp);

long double
frexpl(long double x, int *exp);

/*
 * x times 2^n (C23 7.12.6.3): the inverse of frexp. A result too large
 * to represent is a range error returning ±HUGE_VAL with errno ERANGE;
 * no const attribute.
 */
float
ldexpf(float x, int n);

double
ldexp(double x, int n);

long double
ldexpl(long double x, int n);

/*
 * Split x into an integral part stored in *iptr and a fractional part
 * returned (C23 7.12.6.5); both have x's sign, so modf(-1.5, &i) puts
 * -1.0 in i and returns -0.5. Writes *iptr, so no const attribute.
 */
float
modff(float x, float *iptr);

double
modf(double x, double *iptr);

long double
modfl(long double x, long double *iptr);

/*
 * x * FLT_RADIX^n with FLT_RADIX 2 (C23 7.12.6.6): the scalb* functions
 * differ from ldexp only in the exponent argument's type. A result too
 * large to represent is a range error returning ±HUGE_VAL* with errno
 * ERANGE; no const attribute.
 */
float
scalbnf(float x, int n);

double
scalbn(double x, int n);

long double
scalbnl(long double x, int n);

float
scalblnf(float x, long n);

double
scalbln(double x, long n);

long double
scalblnl(long double x, long n);

/*
 * The smaller of x and y (C23 7.12.12.4), returning -0.0 when the
 * arguments are +0.0 and -0.0. A NaN argument is ignored in favor of the
 * numeric one; two NaNs return a NaN. Pure.
 */
__attribute__((const)) float
fminf(float x, float y);

__attribute__((const)) double
fmin(double x, double y);

__attribute__((const)) long double
fminl(long double x, long double y);

/*
 * The larger of x and y (C23 7.12.12.3), returning +0.0 when the
 * arguments are +0.0 and -0.0. NaN handling as fmin. Pure.
 */
__attribute__((const)) float
fmaxf(float x, float y);

__attribute__((const)) double
fmax(double x, double y);

__attribute__((const)) long double
fmaxl(long double x, long double y);

/*
 * The positive difference x - y when x > y and +0.0 otherwise (C23
 * 7.12.12.2); fdim(x, NaN) and fdim(NaN, x) return a NaN. Pure in the
 * domain-error-free sense (an overflow may still raise an exception
 * through the hardware, which const does not model).
 */
__attribute__((const)) float
fdimf(float x, float y);

__attribute__((const)) double
fdim(double x, double y);

__attribute__((const)) long double
fdiml(long double x, long double y);

/*
 * The floating-point remainder x - n*y, where n is x/y truncated toward
 * zero (C23 7.12.10.1); the result therefore has x's sign. fmod(x, ±0) is
 * a domain error returning NaN with errno EDOM; ±Inf/x is likewise a
 * domain error. errno can be set, so no const attribute.
 */
float
fmodf(float x, float y);

double
fmod(double x, double y);

long double
fmodl(long double x, long double y);

/*
 * The IEEE remainder x - n*y, where n is x/y rounded to the nearest
 * integer (ties to even) (C23 7.12.10.2); |result| <= |y|/2. Domain
 * errors as fmod; errno can be set, so no const attribute.
 */
float
remainderf(float x, float y);

double
remainder(double x, double y);

long double
remainderl(long double x, long double y);

/*
 * As remainder, additionally storing the low bits of the integer
 * quotient n in *quo (C23 7.12.10.3). Writes *quo, so no const
 * attribute.
 */
float
remquof(float x, float y, int *quo);

double
remquo(double x, double y, int *quo);

long double
remquol(long double x, long double y, int *quo);

/*
 * The signed exponent of x as an int (C23 7.12.6.5p1): ilogb(x) is
 * floor(log2 |x|) for a nonzero finite x. ilogb(±0) returns FP_ILOGB0,
 * ilogb(±Inf) and ilogb(NaN) return FP_ILOGBNAN. Pure: the sentinels are
 * returned without touching errno.
 */
__attribute__((const)) int
ilogbf(float x);

__attribute__((const)) int
ilogb(double x);

__attribute__((const)) int
ilogbl(long double x);

/*
 * The signed exponent of x as a floating-point value (C23 7.12.6.6):
 * logb(±0) is -Inf and logb(±Inf) is +Inf, each raising the division-
 * by-zero/invalid exception through the hardware but without an errno
 * path in the representable domain. Pure.
 */
__attribute__((const)) float
logbf(float x);

__attribute__((const)) double
logb(double x);

__attribute__((const)) long double
logbl(long double x);

/*
 * The nearest integral value to x, with halfway cases rounded away from
 * zero, returned as long (C23 7.12.9.9). A result outside the range of
 * long is a range error; no const attribute.
 */
long
lroundf(float x);

long
lround(double x);

long
lroundl(long double x);

/*
 * As lround, returned as long long (C23 7.12.9.10). Range errors as for
 * lround; no const attribute.
 */
long long
llroundf(float x);

long long
llround(double x);

long long
llroundl(long double x);

/*
 * e raised to the power x (C23 7.12.6.1). exp(+0) == exp(-0) == 1;
 * exp(-Inf) == +0; exp(+Inf) == +Inf; exp(NaN) == NaN. A result too
 * large or too small is a range error and sets errno to ERANGE, so no
 * const attribute.
 */
double
exp(double x);

float
expf(float x);

long double
expl(long double x);

/*
 * 2 raised to the power x (C23 7.12.6.2). exp2(+0) == exp2(-0) == 1;
 * exp2(-Inf) == +0; exp2(+Inf) == +Inf; exp2(NaN) == NaN. A result too
 * large or too small is a range error and sets errno to ERANGE, so no
 * const attribute.
 */
double
exp2(double x);

float
exp2f(float x);

long double
exp2l(long double x);

/*
 * e raised to the power x minus 1 (C23 7.12.6.3). expm1(+0) == +0;
 * expm1(-0) == -0; expm1(-Inf) == -1; expm1(+Inf) == +Inf;
 * expm1(NaN) == NaN. A result too large is a range error and sets
 * errno to ERANGE, so no const attribute.
 */
double
expm1(double x);

float
expm1f(float x);

long double
expm1l(long double x);

/*
 * Natural logarithm of x (C23 7.12.6.7). log(+0) == log(-0) == -Inf;
 * log(1) == 0; log(-x) == NaN (domain error); log(+Inf) == +Inf;
 * log(NaN) == NaN. A negative argument is a domain error setting errno
 * to EDOM and a zero argument is a range error setting errno to ERANGE,
 * so no const attribute.
 */
double
log(double x);

float
logf(float x);

long double
logl(long double x);

/*
 * Base-2 logarithm of x (C23 7.12.6.8). log2(1) == 0; log2(2) == 1.
 * Special values, domain errors, and range errors as for log, so no
 * const attribute.
 */
double
log2(double x);

float
log2f(float x);

long double
log2l(long double x);

/*
 * Base-10 logarithm of x (C23 7.12.6.9). log10(1) == 0; log10(10) == 1.
 * Special values, domain errors, and range errors as for log, so no
 * const attribute.
 */
double
log10(double x);

float
log10f(float x);

long double
log10l(long double x);

/*
 * Natural logarithm of 1 + x (C23 7.12.6.13). log1p(+-0) == +-0;
 * log1p(-1) == -Inf (a pole error setting errno to ERANGE); log1p(x) for
 * x < -1 is a domain error setting errno to EDOM; log1p(+Inf) == +Inf;
 * log1p(NaN) == NaN. Accurate for x close to 0, so no const attribute.
 */
double
log1p(double x);

float
log1pf(float x);

long double
log1pl(long double x);

/*
 * Principal square root of x (C23 7.12.5.4). sqrt(+-0) == +-0; sqrt(x)
 * for x < 0 is a domain error returning NaN and setting errno to EDOM;
 * sqrt(+Inf) == +Inf; sqrt(NaN) == NaN. Correctly rounded; no const
 * attribute because of the errno path.
 */
double
sqrt(double x);

float
sqrtf(float x);

long double
sqrtl(long double x);

/*
 * Cube root of x (C23 7.12.5.5). cbrt(+-0) == +-0; cbrt(+-Inf) == +-Inf;
 * cbrt(NaN) == NaN; cbrt(-x) == -cbrt(x). Defined for all reals and never
 * sets errno.
 */
double
cbrt(double x);

float
cbrtf(float x);

long double
cbrtl(long double x);

/*
 * Square root of x*x + y*y without undue overflow or underflow
 * (C23 7.12.5.6). hypot(+-0, +-0) == +0; hypot(+-Inf, y) == +Inf even for
 * NaN y; hypot(x, NaN) == NaN for finite x. The internal scaling avoids
 * spurious overflow, so no errno path exists.
 */
double
hypot(double x, double y);

float
hypotf(float x, float y);

long double
hypotl(long double x, long double y);

/*
 * x raised to the power y (C23 7.12.6.11). pow(x, 0) == 1; pow(1, y) == 1
 * even for NaN y; pow(NaN, 0) == 1; pow(+-0, negative y) == +-Inf (a pole
 * error setting errno to ERANGE); pow(negative finite x, non-integer y) is
 * a domain error setting errno to EDOM; overflow and underflow set errno to
 * ERANGE. No const attribute.
 */
double
pow(double x, double y);

float
powf(float x, float y);

long double
powl(long double x, long double y);

#ifdef __cplusplus
}
#endif

#endif /* VLIBC_MATH_H */