Krishna Pandey a01500b62d [libc][math][c++23] Add expbf16 math function (#161919) ...

This PR adds expbf16 higher math function for BFloat16 type along with
the tests.

---------

Signed-off-by: Krishna Pandey <kpandey81930@gmail.com>

2026-06-27 16:55:55 +05:30

..

check

[libc][math] Add shared functions to check exceptions for exp* functions. (#202503)

2026-06-10 07:40:22 -04:00

acos.h

…

acosbf16.h

[libc][math][c23] Add acosbf16 math function (#184633)

2026-06-08 10:25:16 -04:00

acosf16.h

…

acosf.h

…

acoshf16.h

…

acoshf.h

…

acospif16.h

…

acospif.h

[libc][math][c23] implement C23 acospif math function (#183661)

2026-02-28 04:32:45 +02:00

asin.h

…

asinbf16.h

[libc][math][c23] Add asinbf16 math function (#184170)

2026-03-30 21:29:55 +02:00

asinf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

asinf.h

…

asinhf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

asinhf.h

…

asinpi.h

[libc][math][c23] implement double-precision asinpi (#188158)

2026-03-29 10:18:07 -04:00

asinpif16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

asinpif.h

[libc][math][c23] implement asinpif function (#181511)

2026-02-26 05:05:49 +02:00

atan2.h

…

atan2f16.h

[libc][math][c23] Add atan2f16 function (#183531)

2026-03-13 22:12:44 +02:00

atan2f128.h

…

atan2f.h

…

atan.h

…

atanbf16.h

[libc][math][c23] Add atanbf16 function (#184019)

2026-03-21 11:09:11 -04:00

atanf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

atanf.h

…

atanhf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

atanhf.h

…

atanpif16.h

[libc][math] Refactored atanpif16 to header only (#184316)

2026-03-16 18:57:29 +02:00

bf16add.h

[libc][math] Refactor bf16add to header only (#181392)

2026-02-15 03:38:58 +02:00

bf16addf128.h

[libc][math] Refactor bf16addf128 to header only (#181058)

2026-02-14 05:49:18 +00:00

bf16addf.h

[libc][math] Refactor bf16addf to header only (#181230)

2026-02-17 21:31:57 +00:00

bf16addl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

bf16div.h

[libc][math] Refactor bf16div to be header-only (#181400)

2026-03-13 20:08:00 +00:00

bf16divf128.h

[libc][math] Refactor bf16divf128 to Header Only (#186641)

2026-03-19 01:47:22 +02:00

bf16divf.h

[libc][math] Refactor bf16divf implementation to header-only in src/__support/math folder. (#181086)

2026-02-17 23:52:03 +02:00

bf16divl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

bf16fma.h

[libc][math] Refactor bf16fma to Header Only (#182572)

2026-03-16 17:05:54 +00:00

bf16fmaf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16fmaf.h

[libc][math] Refactored bf16fmaf to Header Only (#181919)

2026-02-18 00:34:02 +02:00

bf16fmal.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

bf16mul.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16mulf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16mulf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16mull.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

bf16sub.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16subf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16subf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

bf16subl.h

[libc][math] Refactor bf16subl to header-only (#194498)

2026-04-28 03:39:12 +03:00

canonicalize.h

[libc][math] Refactor canonicalize function family to header-only (#181467)

2026-02-16 11:28:14 +02:00

canonicalizebf16.h

[libc][math] Refactor canonicalize function family to header-only (#181467)

2026-02-16 11:28:14 +02:00

canonicalizef16.h

[libc][math] Refactor canonicalize function family to header-only (#181467)

2026-02-16 11:28:14 +02:00

canonicalizef128.h

[libc][math] Refactor canonicalize function family to header-only (#181467)

2026-02-16 11:28:14 +02:00

canonicalizef.h

[libc][math] Refactor canonicalize function family to header-only (#181467)

2026-02-16 11:28:14 +02:00

canonicalizel.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

cbrt.h

…

cbrtbf16.h

[libc][math] Refactor cbrtbf16 function header-only (#188204)

2026-04-09 00:40:22 +02:00

cbrtf16.h

[libc][math][c23] Implement higher math function cbrtf16 in LLVM libc (#132484)

2026-06-15 22:10:19 +00:00

cbrtf.h

[libc] cbrtf guard to sync with general format (#188207)

2026-03-24 10:56:54 +00:00

ceil.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ceilbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ceilf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ceilf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ceilf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ceill.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

copysign.h

[libc][math] Refactor copysign family to header-only (#182137)

2026-04-13 18:03:52 +02:00

copysignbf16.h

[libc][math] Refactor copysign family to header-only (#182137)

2026-04-13 18:03:52 +02:00

copysignf16.h

[libc][math] Refactor copysign family to header-only (#182137)

2026-04-13 18:03:52 +02:00

copysignf128.h

[libc][math] Refactor copysign family to header-only (#182137)

2026-04-13 18:03:52 +02:00

copysignf.h

[libc][math] Refactor copysign family to header-only (#182137)

2026-04-13 18:03:52 +02:00

copysignl.h

[libc][math] Refactor copysign family to header-only (#182137)

2026-04-13 18:03:52 +02:00

cos.h

…

cosf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

cosf.h

…

coshf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

coshf.h

…

cospif16.h

[libc] Fix all guard comments for cos and Acos functions (#188612)

2026-03-25 17:40:46 -04:00

cospif.h

…

daddf128.h

[libc][math] Refactor dadd family to header-only (#182142)

2026-03-19 06:37:35 +02:00

daddl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

ddivf128.h

[libc][math] Refactor ddiv family to header-only (#182149)

2026-04-24 20:49:28 +03:00

ddivl.h

[libc][math] Refactor ddiv family to header-only (#182149)

2026-04-24 20:49:28 +03:00

dfmaf128.h

[libc][math] Refactor dfmaf128 to Header Only (#176480)

2026-01-23 21:02:46 +02:00

dfmal.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

dmulf128.h

[libc][math] Refactor dmul family to header-only (#182151)

2026-04-24 17:49:19 +03:00

dmull.h

[libc][math] Refactor dmul family to header-only (#182151)

2026-04-24 17:49:19 +03:00

dsqrtf128.h

[libc][math] Refactor dsqrtf128 to header-only (#194552)

2026-04-28 10:03:24 +03:00

dsqrtl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

dsubf128.h

[libc][math] Refactor dsub family to header-only (#182160)

2026-04-25 10:09:30 +03:00

dsubl.h

[libc][math] Refactor dsub family to header-only (#182160)

2026-04-25 10:09:30 +03:00

erfcf16.h

[libc][math] Implement C23 half precision erfc function (#180930)

2026-03-27 10:42:03 -04:00

erff16.h

[libc][math] Implement C23 half precision erf function (#179251)

2026-03-13 10:16:59 -04:00

erff.h

…

exp2.h

…

exp2f16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

exp2f.h

…

exp2m1f16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

exp2m1f.h

…

exp10.h

…

exp10f16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

exp10f.h

…

exp10m1f16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

exp10m1f.h

…

exp.h

…

expbf16.h

[libc][math][c++23] Add expbf16 math function (#161919)

2026-06-27 16:55:55 +05:30

expf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

expf.h

…

expm1.h

…

expm1f16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

expm1f.h

…

f16add.h

[libc][math] Refactor f16add Math Functions to Header Only (#181777)

2026-02-18 15:55:53 +02:00

f16addf128.h

[libc][math] Refactor f16add Math Functions to Header Only (#181777)

2026-02-18 15:55:53 +02:00

f16addf.h

[libc][math] Refactor f16add Math Functions to Header Only (#181777)

2026-02-18 15:55:53 +02:00

f16addl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

f16div.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16divf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16divf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16divl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

f16fma.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16fmaf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16fmaf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16fmal.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

f16mul.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16mulf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16mulf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16mull.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

f16sqrt.h

[libc][math] Refactor f16sqrt to Header Only (#177167)

2026-01-30 04:27:03 +02:00

f16sqrtf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16sqrtf.h

[libc][math] Refactor f16sqrtf to Header Only. (#180749)

2026-02-12 03:52:40 +00:00

f16sqrtl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

f16sub.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16subf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16subf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

f16subl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

fabs.h

[libc][math] Refactor fabs family to header-only (#182173)

2026-04-24 22:47:39 +03:00

fabsbf16.h

[libc][math] Refactor fabs family to header-only (#182173)

2026-04-24 22:47:39 +03:00

fabsf16.h

[libc][math] Refactor fabs family to header-only (#182173)

2026-04-24 22:47:39 +03:00

fabsf128.h

[libc][math] Refactor fabs family to header-only (#182173)

2026-04-24 22:47:39 +03:00

fabsf.h

[libc][math] Refactor fabs family to header-only (#182173)

2026-04-24 22:47:39 +03:00

fabsl.h

[libc][math] Refactor fabs family to header-only (#182173)

2026-04-24 22:47:39 +03:00

fadd.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

faddf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

faddl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

fdim.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fdimbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fdimf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fdimf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fdimf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fdiml.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

fdiv.h

[libc][math] Refactor fdiv family to header-only (#182192)

2026-04-26 00:57:03 +03:00

fdivf128.h

[libc][math] Refactor fdiv family to header-only (#182192)

2026-04-26 00:57:03 +03:00

fdivl.h

[libc][math] Refactor fdiv family to header-only (#182192)

2026-04-26 00:57:03 +03:00

ffma.h

[libc][math] Refactor ffma implementation to header-only in src/__support/math folder (#175304).

2026-02-14 06:08:36 +00:00

ffmaf128.h

[libc][math] Refactor ffmaf128 into a header only. (#184751)

2026-03-05 23:31:40 +02:00

ffmal.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

floor.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

floorbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

floorf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

floorf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

floorf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

floorl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

fma.h

[libc][math] Refactor fma implementation to header-only in src/__support/math folder. (#163968)

2026-03-17 21:24:27 +02:00

fmabf16.h

[libc][math][c++23] Add Fmabf16 math function (#182836)

2026-03-13 05:33:52 +00:00

fmaf16.h

[libc][math] Refactor fmaf16 implementation to header-only in src/__support/math folder. (#163977)

2026-03-17 21:35:08 +02:00

fmaf.h

[libc][math] Refactor fmaf implementation to header-only in src/__support/math folder. (#163970)

2026-03-17 21:33:06 +02:00

fmax.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fmaxbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fmaxf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fmaxf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fmaxf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fmaximum_mag_num.h

Reland "[libc][math] Refactor fmaximum_mag_num family to header-only" (#194194)

2026-04-26 02:48:16 +03:00

fmaximum_mag_numbf16.h

Reland "[libc][math] Refactor fmaximum_mag_num family to header-only" (#194194)

2026-04-26 02:48:16 +03:00

fmaximum_mag_numf16.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fmaximum_mag_numf128.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fmaximum_mag_numf.h

Reland "[libc][math] Refactor fmaximum_mag_num family to header-only" (#194194)

2026-04-26 02:48:16 +03:00

fmaximum_mag_numl.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fmaximum_mag.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fmaximum_magbf16.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fmaximum_magf16.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fmaximum_magf128.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fmaximum_magf.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fmaximum_magl.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fmaximum_num.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fmaximum_numbf16.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fmaximum_numf16.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fmaximum_numf128.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fmaximum_numf.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fmaximum_numl.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fmaximum.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fmaximumbf16.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fmaximumf16.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fmaximumf128.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fmaximumf.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fmaximuml.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fmaxl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

fmin.h

[libc][math] Refactor fmin family to header-only (#194549)

2026-04-28 09:28:45 +03:00

fminbf16.h

[libc][math] Refactor fmin family to header-only (#194549)

2026-04-28 09:28:45 +03:00

fminf16.h

[libc][math] Refactor fmin family to header-only (#194549)

2026-04-28 09:28:45 +03:00

fminf128.h

[libc][math] Refactor fmin family to header-only (#194549)

2026-04-28 09:28:45 +03:00

fminf.h

[libc][math] Refactor fmin family to header-only (#194549)

2026-04-28 09:28:45 +03:00

fminimum_mag_num.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fminimum_mag_numbf16.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fminimum_mag_numf16.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fminimum_mag_numf128.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fminimum_mag_numf.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fminimum_mag_numl.h

[libc][math] Refactor fmaximum-mag-num-fminimum-mag-num family to header-only (#195415)

2026-05-02 08:41:00 +03:00

fminimum_mag.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fminimum_magbf16.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fminimum_magf16.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fminimum_magf128.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fminimum_magf.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fminimum_magl.h

[libc][math] Refactor fmaximum-mag-fminimum-mag family to header-only (#195394)

2026-05-02 05:50:20 +03:00

fminimum_num.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fminimum_numbf16.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fminimum_numf16.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fminimum_numf128.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fminimum_numf.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fminimum_numl.h

[libc][math] Refactor fmaximum_num-fminimum_num family to header-only (#194562)

2026-04-28 11:11:09 +03:00

fminimum.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fminimumbf16.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fminimumf16.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fminimumf128.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fminimumf.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fminimuml.h

[libc][math] Refactor fmaximum-fminimum family to header-only (#194533)

2026-04-28 08:49:15 +03:00

fminl.h

[libc][math] Refactor fmin family to header-only (#194549)

2026-04-28 09:28:45 +03:00

fmod.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

fmodbf16.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

fmodf16.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

fmodf128.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

fmodf.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

fmodl.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

fmul.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

fmulf128.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

fmull.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

frexp.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

frexpbf16.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

frexpf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

frexpf128.h

…

frexpf.h

…

frexpl.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

fromfp.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpbf16.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpf16.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpf128.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpf.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpl.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpx.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpxbf16.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpxf16.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpxf128.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpxf.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fromfpxl.h

[libc][math] Refactor fromfp family to header-only (#195413)

2026-05-02 08:30:01 +03:00

fsqrt.h

…

fsqrtf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

fsqrtl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

fsub.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

fsubf128.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

fsubl.h

[libc][math] Refactor fmul-fsub-frexp family to header-only (#195431)

2026-05-02 12:52:04 +03:00

getpayload.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

getpayloadbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

getpayloadf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

getpayloadf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

getpayloadf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

getpayloadl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

hypot.h

[libc][math] Move hypot to shared/math and make it constexpr (#177588)

2026-03-13 19:57:05 +00:00

hypotbf16.h

[libc][math][c23] Add hypotbf16 function (#183460)

2026-03-13 10:11:33 -04:00

hypotf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

hypotf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ilogb.h

[libc][math] Refactor ilogb implementation to header-only in src/__support/math folder. (#175504)

2026-01-28 07:45:47 +02:00

ilogbbf16.h

[libc][math] Refactor ilogbbf16 to header-only (#194503)

2026-04-28 04:13:16 +03:00

ilogbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ilogbf128.h

[libc][math] Refactor ilogbf128 to Header Only (#175396)

2026-01-27 02:17:06 +02:00

ilogbf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ilogbl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

iscanonical.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

iscanonicalbf16.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

iscanonicalf16.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

iscanonicalf128.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

iscanonicalf.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

iscanonicall.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

isnan.h

[libc][math] Refactor isnan family to header-only (#195598)

2026-05-04 10:36:38 +03:00

isnanf16.h

[libc][math] Implement isnanf16 header-only function (#198115)

2026-05-24 11:28:50 -04:00

isnanf128.h

[libc][math] Add isnanf128 (#199206)

2026-06-10 17:43:56 -04:00

isnanf.h

[libc][math] Refactor isnan family to header-only (#195598)

2026-05-04 10:36:38 +03:00

isnanl.h

[libc][math] Refactor isnan family to header-only (#195598)

2026-05-04 10:36:38 +03:00

issignaling.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

issignalingbf16.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

issignalingf16.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

issignalingf128.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

issignalingf.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

issignalingl.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

ldexp.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

ldexpbf16.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

ldexpf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

ldexpf128.h

…

ldexpf.h

…

ldexpl.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

llogb.h

[libc][math] Refactor llogb to Header Only (#175524)

2026-01-27 05:56:49 +02:00

llogbbf16.h

[libc][math] Refactor llogbbf16 to header-only (#194509)

2026-04-28 04:36:17 +03:00

llogbf16.h

[libc][math] Refactor llogbf16 to header-only (#178078)

2026-01-28 07:09:14 +02:00

llogbf128.h

[libc][math] Refactor llogbf128 to header-only (#175617)

2026-01-28 19:36:29 +00:00

llogbf.h

[libc][math] Refactor llogbf to Header Only. (#176494)

2026-01-17 02:06:46 +02:00

llogbl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

llrint.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llrintbf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llrintf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llrintf128.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llrintf.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llrintl.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llround.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llroundbf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llroundf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llroundf128.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llroundf.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

llroundl.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

log1p.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

log1pf.h

[libc][math] Refactor log1pf to Header Only. (#176525)

2026-02-10 23:40:13 +02:00

log2.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

log2f16.h

[libc][math] Refactor log2f16 to Header Only. (#176526)

2026-02-10 22:33:22 +00:00

log2f.h

[libc][math] Refactor log2f to Header Only. (#176527)

2026-02-10 22:59:44 +00:00

log2p1f16.h

[libc][math] Fix: add log2p1f16 to shared math (#189179)

2026-04-13 10:57:16 +02:00

log10.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

log10f16.h

[libc][math] Refactor log10f16 to Header Only. (#176523)

2026-02-10 23:37:23 +02:00

log10f.h

[libc][math] Refactor log10f to Header Only. (#176520)

2026-02-10 22:16:36 +00:00

log10p1f16.h

[libc][math] Fix: add log10p1f16 to shared math (#189185)

2026-04-13 11:00:03 +02:00

log_bf16.h

[libc][math] Refactor log_bf16 to Header (#186618)

2026-03-16 17:13:19 +00:00

log.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

logb.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

logbbf16.h

[libc][math] Refactor logbbf16 to header-only (#189194)

2026-04-18 21:41:15 +02:00

logbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

logbf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

logbf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

logbl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

logf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

logf.h

[libc][math] Refractor logf to Header only (#176834)

2026-01-26 21:59:14 +02:00

lrint.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lrintbf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lrintf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lrintf128.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lrintf.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lrintl.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lround.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lroundbf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lroundf16.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lroundf128.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lroundf.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

lroundl.h

[libc][math] Refactor lrint_lround family to header-only (#195441)

2026-05-02 15:25:49 +03:00

modf.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

modfbf16.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

modff16.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

modff128.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

modff.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

modfl.h

[libc][math] Refactor fmod-modf family to header-only (#195406)

2026-05-02 08:03:26 +03:00

nan.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

nanbf16.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

nanf16.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

nanf128.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

nanf.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

nanl.h

[libc][math] Refactor iscanonical-issignaling-nan family to header-only (#195581)

2026-05-04 09:31:11 +03:00

nearbyint.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

nearbyintbf16.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

nearbyintf16.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

nearbyintf128.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

nearbyintf.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

nearbyintl.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

nextafter.h

[libc][math] Refactor nextafter family to header-only (#181673)

2026-02-27 01:52:57 +02:00

nextafterbf16.h

[libc][math] Refactor nextafter family to header-only (#181673)

2026-02-27 01:52:57 +02:00

nextafterf16.h

[libc][math] Refactor nextafter family to header-only (#181673)

2026-02-27 01:52:57 +02:00

nextafterf128.h

[libc][math] Refactor nextafter family to header-only (#181673)

2026-02-27 01:52:57 +02:00

nextafterf.h

[libc][math] Refactor nextafter family to header-only (#181673)

2026-02-27 01:52:57 +02:00

nextafterl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

nextdown.h

[libc][math] Refactor nextdown family to header-only (#181679)

2026-02-24 21:38:33 +02:00

nextdownbf16.h

[libc][math] Refactor nextdown family to header-only (#181679)

2026-02-24 21:38:33 +02:00

nextdownf16.h

[libc][math] Refactor nextdown family to header-only (#181679)

2026-02-24 21:38:33 +02:00

nextdownf128.h

[libc][math] Refactor nextdown family to header-only (#181679)

2026-02-24 21:38:33 +02:00

nextdownf.h

[libc][math] Refactor nextdown family to header-only (#181679)

2026-02-24 21:38:33 +02:00

nextdownl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

nexttoward.h

[libc][NFC] Guard long double type in shared_math_tests. (#189373)

2026-03-30 10:05:16 -04:00

nexttowardbf16.h

[libc][NFC] Guard long double type in shared_math_tests. (#189373)

2026-03-30 10:05:16 -04:00

nexttowardf16.h

[libc][NFC] Guard long double type in shared_math_tests. (#189373)

2026-03-30 10:05:16 -04:00

nexttowardf.h

[libc][NFC] Guard long double type in shared_math_tests. (#189373)

2026-03-30 10:05:16 -04:00

nexttowardl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

nextup.h

[libc][math] Refactor nextup family to header-only (#181688)

2026-02-25 17:58:11 +00:00

nextupbf16.h

[libc][math] Refactor nextup family to header-only (#181688)

2026-02-25 17:58:11 +00:00

nextupf16.h

[libc][math] Refactor nextup family to header-only (#181688)

2026-02-25 17:58:11 +00:00

nextupf128.h

[libc][math] Refactor nextup family to header-only (#181688)

2026-02-25 17:58:11 +00:00

nextupf.h

[libc][math] Refactor nextup family to header-only (#181688)

2026-02-25 17:58:11 +00:00

nextupl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

pow.h

[libc][math] Refactor pow to Header Only. (#176529)

2026-02-10 23:11:58 +00:00

powf.h

[libc][math] Refactor powf to Header Only. (#176531)

2026-02-10 23:31:05 +00:00

remainder.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remainderbf16.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remainderf16.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remainderf128.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remainderf.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remainderl.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remquo.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remquobf16.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remquof16.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remquof128.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remquof.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

remquol.h

[libc][math] Refactor remainder-remquo family to header-only (#195421)

2026-05-02 10:14:35 +03:00

rint.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

rintbf16.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

rintf16.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

rintf128.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

rintf.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

rintl.h

[libc][math] Refactor rint-nearbyint family to header-only (#195577)

2026-05-04 06:32:34 +03:00

round.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundbf16.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundeven.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundevenbf16.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundevenf16.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundevenf128.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundevenf.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundevenl.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundf16.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundf128.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundf.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

roundl.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

rsqrtf16.h

…

rsqrtf.h

…

scalbln.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalblnbf16.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalblnf16.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalblnf128.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalblnf.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalblnl.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalbn.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalbnbf16.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalbnf16.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalbnf128.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalbnf.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

scalbnl.h

[libc][math] Refactor scalbln-scalbn-ldexp family to header-only (#195423)

2026-05-02 11:08:30 +03:00

setpayload.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

setpayloadsig.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadsigbf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadsigf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadsigf128.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadsigf.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

setpayloadsigl.h

[libc] Guard long double shared math functions against double-double. (#188909)

2026-03-27 01:51:17 -04:00

sin.h

…

sincos.h

[libc][math] Refactor sincos implementation to header only (#177522)

2026-02-17 23:57:05 +02:00

sincosf.h

[libc][math] Refactor sincosf implementation to header only (#177523)

2026-01-30 03:05:51 +00:00

sinf16.h

[libc][math] Refactor sinf16 implementation to header-only in src/__support/math folder. (#178062)

2026-01-27 08:17:33 -05:00

sinf.h

[libc][math] Refactor sinf implementation to header-only in src/__support/math folder. (#177963)

2026-01-26 16:41:46 -05:00

sinhf16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

sinhf.h

[libc][math] Refractor sinhf to Header only (#177336)

2026-01-27 02:15:00 +02:00

sinpif16.h

[libc][math] Refactor sinpif16 to header only. (#178503)

2026-02-16 11:34:52 +02:00

sinpif.h

[libc][math] Refactor sinpif to Header Only. (#176580)

2026-01-28 07:42:22 +02:00

sqrt.h

[libc][math] Refactor sqrt to header-only (#178335)

2026-01-29 03:10:33 +00:00

sqrtbf16.h

[libc][math] Refactor sqrtbf16 function header-only (#187849)

2026-03-22 00:51:40 +02:00

sqrtf16.h

[libc][math] Refactor sqrtf16 to Header Only (#177726)

2026-01-28 06:43:52 +02:00

sqrtf128.h

[libc][math] Refactor sqrtf128 to header only (#177760)

2026-02-07 16:03:49 +02:00

sqrtf.h

[libc][math] Refactor sqrtf to header-only (#178778)

2026-01-30 05:31:04 +00:00

sqrtl.h

[libc][math] Refactor sqrtl family to header-only (#194510)

2026-04-28 06:58:31 +03:00

tan.h

[libc][math] Refactor tan implementation to header-only in src/__support/math folder. (#177224)

2026-01-23 23:56:05 +02:00

tanbf16.h

[libc][math][c23] Add tanbf16 math function (#185100)

2026-06-25 14:25:35 +00:00

tanf16.h

[libc][math] Refactor tanf16 to header only (#181523)

2026-02-18 15:50:11 +02:00

tanf.h

[libc][math] Refactor tanf implementation to header-only in src/__support/math folder. (#177730)

2026-01-25 01:54:34 +02:00

tanhf16.h

[libc][math] Refactor tanhf16 implementation to header-only in src/__support/math folder. (#178645)

2026-02-15 03:37:00 +02:00

tanhf.h

[libc][math] Refactor tanhf implementation to header-only in src/__support/math folder. (#178554)

2026-02-14 06:04:38 +00:00

tanpif16.h

[libc][math] Cleanup shared/math (#183971)

2026-03-01 04:08:52 +02:00

tanpif.h

[libc][math] Refactor tanpif to header only (#181525)

2026-02-18 15:53:27 +02:00

totalorder.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalorderbf16.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalorderf16.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalorderf128.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalorderf.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalorderl.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalordermag.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalordermagbf16.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalordermagf16.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalordermagf128.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalordermagf.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

totalordermagl.h

[libc][math] Refactor totalorder, totalordermag family to header-only (#195399)

2026-05-02 07:01:34 +03:00

trunc.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

truncbf16.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

truncf16.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

truncf128.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

truncf.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

truncl.h

[libc][math] Refactor round-roundeven-trunc family to header-only (#195590)

2026-05-04 10:19:35 +03:00

ufromfp.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpbf16.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpf16.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpf128.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpf.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpl.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpx.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpxbf16.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpxf16.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpxf128.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpxf.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00

ufromfpxl.h

[libc][math] Refactor ufromfp family to header-only (#195395)

2026-05-02 06:22:17 +03:00