diff --git a/libc/config/linux/aarch64/entrypoints.txt b/libc/config/linux/aarch64/entrypoints.txt index 6abb35ab0ead70..78da7f0b334b1f 100644 --- a/libc/config/linux/aarch64/entrypoints.txt +++ b/libc/config/linux/aarch64/entrypoints.txt @@ -366,6 +366,30 @@ set(TARGET_LIBM_ENTRYPOINTS libc.src.math.fmin libc.src.math.fminf libc.src.math.fminl + libc.src.math.fmaximum + libc.src.math.fmaximumf + libc.src.math.fmaximuml + libc.src.math.fmaximum_num + libc.src.math.fmaximum_numf + libc.src.math.fmaximum_numl + libc.src.math.fmaximum_mag + libc.src.math.fmaximum_magf + libc.src.math.fmaximum_magl + libc.src.math.fmaximum_mag_num + libc.src.math.fmaximum_mag_numf + libc.src.math.fmaximum_mag_numl + libc.src.math.fminimum + libc.src.math.fminimumf + libc.src.math.fminimuml + libc.src.math.fminimum_num + libc.src.math.fminimum_numf + libc.src.math.fminimum_numl + libc.src.math.fminimum_mag + libc.src.math.fminimum_magf + libc.src.math.fminimum_magl + libc.src.math.fminimum_mag_num + libc.src.math.fminimum_mag_numf + libc.src.math.fminimum_mag_numl libc.src.math.fmod libc.src.math.fmodf libc.src.math.fmodl @@ -466,6 +490,14 @@ if(LIBC_TYPES_HAS_FLOAT128) libc.src.math.floorf128 libc.src.math.fmaxf128 libc.src.math.fminf128 + libc.src.math.fmaximumf128 + libc.src.math.fmaximum_numf128 + libc.src.math.fmaximum_magf128 + libc.src.math.fmaximum_mag_numf128 + libc.src.math.fminimumf128 + libc.src.math.fminimum_numf128 + libc.src.math.fminimum_magf128 + libc.src.math.fminimum_mag_numf128 libc.src.math.fmodf128 libc.src.math.frexpf128 libc.src.math.ilogbf128 diff --git a/libc/config/linux/arm/entrypoints.txt b/libc/config/linux/arm/entrypoints.txt index 3bc5d8efc9d26b..6e63e270280e7a 100644 --- a/libc/config/linux/arm/entrypoints.txt +++ b/libc/config/linux/arm/entrypoints.txt @@ -234,6 +234,30 @@ set(TARGET_LIBM_ENTRYPOINTS libc.src.math.fmin libc.src.math.fminf libc.src.math.fminl + libc.src.math.fmaximum + libc.src.math.fmaximumf + libc.src.math.fmaximuml + libc.src.math.fmaximum_num + libc.src.math.fmaximum_numf + libc.src.math.fmaximum_numl + libc.src.math.fmaximum_mag + libc.src.math.fmaximum_magf + libc.src.math.fmaximum_magl + libc.src.math.fmaximum_mag_num + libc.src.math.fmaximum_mag_numf + libc.src.math.fmaximum_mag_numl + libc.src.math.fminimum + libc.src.math.fminimumf + libc.src.math.fminimuml + libc.src.math.fminimum_num + libc.src.math.fminimum_numf + libc.src.math.fminimum_numl + libc.src.math.fminimum_mag + libc.src.math.fminimum_magf + libc.src.math.fminimum_magl + libc.src.math.fminimum_mag_num + libc.src.math.fminimum_mag_numf + libc.src.math.fminimum_mag_numl libc.src.math.fmod libc.src.math.fmodf libc.src.math.frexp diff --git a/libc/config/linux/riscv/entrypoints.txt b/libc/config/linux/riscv/entrypoints.txt index e34c87ec6b5d34..5aae4e246cfb3c 100644 --- a/libc/config/linux/riscv/entrypoints.txt +++ b/libc/config/linux/riscv/entrypoints.txt @@ -374,6 +374,30 @@ set(TARGET_LIBM_ENTRYPOINTS libc.src.math.fmax libc.src.math.fmaxf libc.src.math.fmaxl + libc.src.math.fmaximum + libc.src.math.fmaximumf + libc.src.math.fmaximuml + libc.src.math.fmaximum_num + libc.src.math.fmaximum_numf + libc.src.math.fmaximum_numl + libc.src.math.fmaximum_mag + libc.src.math.fmaximum_magf + libc.src.math.fmaximum_magl + libc.src.math.fmaximum_mag_num + libc.src.math.fmaximum_mag_numf + libc.src.math.fmaximum_mag_numl + libc.src.math.fminimum + libc.src.math.fminimumf + libc.src.math.fminimuml + libc.src.math.fminimum_num + libc.src.math.fminimum_numf + libc.src.math.fminimum_numl + libc.src.math.fminimum_mag + libc.src.math.fminimum_magf + libc.src.math.fminimum_magl + libc.src.math.fminimum_mag_num + libc.src.math.fminimum_mag_numf + libc.src.math.fminimum_mag_numl libc.src.math.fmod libc.src.math.fmodf libc.src.math.fmodl @@ -474,6 +498,14 @@ if(LIBC_TYPES_HAS_FLOAT128) libc.src.math.floorf128 libc.src.math.fmaxf128 libc.src.math.fminf128 + libc.src.math.fmaximumf128 + libc.src.math.fmaximum_numf128 + libc.src.math.fmaximum_magf128 + libc.src.math.fmaximum_mag_numf128 + libc.src.math.fminimumf128 + libc.src.math.fminimum_numf128 + libc.src.math.fminimum_magf128 + libc.src.math.fminimum_mag_numf128 libc.src.math.fmodf128 libc.src.math.frexpf128 libc.src.math.ilogbf128 diff --git a/libc/config/linux/x86_64/entrypoints.txt b/libc/config/linux/x86_64/entrypoints.txt index 2f5a3bffadc091..29080df5492274 100644 --- a/libc/config/linux/x86_64/entrypoints.txt +++ b/libc/config/linux/x86_64/entrypoints.txt @@ -385,6 +385,30 @@ set(TARGET_LIBM_ENTRYPOINTS libc.src.math.fmax libc.src.math.fmaxf libc.src.math.fmaxl + libc.src.math.fmaximum + libc.src.math.fmaximumf + libc.src.math.fmaximuml + libc.src.math.fmaximum_num + libc.src.math.fmaximum_numf + libc.src.math.fmaximum_numl + libc.src.math.fmaximum_mag + libc.src.math.fmaximum_magf + libc.src.math.fmaximum_magl + libc.src.math.fmaximum_mag_num + libc.src.math.fmaximum_mag_numf + libc.src.math.fmaximum_mag_numl + libc.src.math.fminimum + libc.src.math.fminimumf + libc.src.math.fminimuml + libc.src.math.fminimum_num + libc.src.math.fminimum_numf + libc.src.math.fminimum_numl + libc.src.math.fminimum_mag + libc.src.math.fminimum_magf + libc.src.math.fminimum_magl + libc.src.math.fminimum_mag_num + libc.src.math.fminimum_mag_numf + libc.src.math.fminimum_mag_numl libc.src.math.fmod libc.src.math.fmodf libc.src.math.fmodl @@ -499,6 +523,14 @@ if(LIBC_TYPES_HAS_FLOAT128) libc.src.math.floorf128 libc.src.math.fmaxf128 libc.src.math.fminf128 + libc.src.math.fmaximumf128 + libc.src.math.fmaximum_numf128 + libc.src.math.fmaximum_magf128 + libc.src.math.fmaximum_mag_numf128 + libc.src.math.fminimumf128 + libc.src.math.fminimum_numf128 + libc.src.math.fminimum_magf128 + libc.src.math.fminimum_mag_numf128 libc.src.math.fmodf128 libc.src.math.frexpf128 libc.src.math.fromfpf128 diff --git a/libc/config/windows/entrypoints.txt b/libc/config/windows/entrypoints.txt index d6227a427afe2b..f4456f561ec017 100644 --- a/libc/config/windows/entrypoints.txt +++ b/libc/config/windows/entrypoints.txt @@ -153,6 +153,30 @@ set(TARGET_LIBM_ENTRYPOINTS libc.src.math.fmax libc.src.math.fmaxf libc.src.math.fmaxl + libc.src.math.fmaximum + libc.src.math.fmaximumf + libc.src.math.fmaximuml + libc.src.math.fmaximum_num + libc.src.math.fmaximum_numf + libc.src.math.fmaximum_numl + libc.src.math.fmaximum_mag + libc.src.math.fmaximum_magf + libc.src.math.fmaximum_magl + libc.src.math.fmaximum_mag_num + libc.src.math.fmaximum_mag_numf + libc.src.math.fmaximum_mag_numl + libc.src.math.fminimum + libc.src.math.fminimumf + libc.src.math.fminimuml + libc.src.math.fminimum_num + libc.src.math.fminimum_numf + libc.src.math.fminimum_numl + libc.src.math.fminimum_mag + libc.src.math.fminimum_magf + libc.src.math.fminimum_magl + libc.src.math.fminimum_mag_num + libc.src.math.fminimum_mag_numf + libc.src.math.fminimum_mag_numl libc.src.math.fmod libc.src.math.fmodf libc.src.math.fmodl diff --git a/libc/spec/stdc.td b/libc/spec/stdc.td index 7407ead17711aa..89b43f06778d95 100644 --- a/libc/spec/stdc.td +++ b/libc/spec/stdc.td @@ -406,6 +406,46 @@ def StdC : StandardSpec<"stdc"> { FunctionSpec<"fmaxf", RetValSpec, [ArgSpec, ArgSpec]>, FunctionSpec<"fmaxl", RetValSpec, [ArgSpec, ArgSpec]>, GuardedFunctionSpec<"fmaxf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fmaximum", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximumf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximuml", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fmaximumf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fmaximum_num", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_numf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_numl", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fmaximum_numf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fmaximum_mag", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_magf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_magl", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fmaximum_magf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fmaximum_mag_num", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_mag_numf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_mag_numl", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fmaximum_mag_numf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fminimum", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimumf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimuml", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fminimumf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fminimum_num", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimum_numf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fmaximum_numl", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fminimum_numf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fminimum_mag", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimum_magf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimum_magl", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fminimum_magf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, + + FunctionSpec<"fminimum_mag_num", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimum_mag_numf", RetValSpec, [ArgSpec, ArgSpec]>, + FunctionSpec<"fminimum_mag_numl", RetValSpec, [ArgSpec, ArgSpec]>, + GuardedFunctionSpec<"fminimum_mag_numf128", RetValSpec, [ArgSpec, ArgSpec], "LIBC_TYPES_HAS_FLOAT128">, FunctionSpec<"fma", RetValSpec, [ArgSpec, ArgSpec, ArgSpec]>, FunctionSpec<"fmaf", RetValSpec, [ArgSpec, ArgSpec, ArgSpec]>, diff --git a/libc/src/__support/FPUtil/BasicOperations.h b/libc/src/__support/FPUtil/BasicOperations.h index a19d6d0bef08ff..b8cff982d3a6ea 100644 --- a/libc/src/__support/FPUtil/BasicOperations.h +++ b/libc/src/__support/FPUtil/BasicOperations.h @@ -11,6 +11,7 @@ #include "FPBits.h" +#include "FEnvImpl.h" #include "src/__support/CPP/type_traits.h" #include "src/__support/common.h" @@ -58,6 +59,110 @@ LIBC_INLINE T fmax(T x, T y) { } } +template , int> = 0> +LIBC_INLINE T fmaximum(T x, T y) { + FPBits bitx(x), bity(y); + + if (bitx.is_nan()) + return x; + if (bity.is_nan()) + return y; + if (bitx.sign() != bity.sign()) + return (bitx.is_neg() ? y : x); + return x > y ? x : y; +} + +template , int> = 0> +LIBC_INLINE T fminimum(T x, T y) { + const FPBits bitx(x), bity(y); + + if (bitx.is_nan()) + return x; + if (bity.is_nan()) + return y; + if (bitx.sign() != bity.sign()) + return (bitx.is_neg()) ? x : y; + return x < y ? x : y; +} + +template , int> = 0> +LIBC_INLINE T fmaximum_num(T x, T y) { + FPBits bitx(x), bity(y); + if (bitx.is_signaling_nan() || bity.is_signaling_nan()) { + fputil::raise_except_if_required(FE_INVALID); + if (bitx.is_nan() && bity.is_nan()) + return FPBits::quiet_nan().get_val(); + } + if (bitx.is_nan()) + return y; + if (bity.is_nan()) + return x; + if (bitx.sign() != bity.sign()) + return (bitx.is_neg() ? y : x); + return x > y ? x : y; +} + +template , int> = 0> +LIBC_INLINE T fminimum_num(T x, T y) { + FPBits bitx(x), bity(y); + if (bitx.is_signaling_nan() || bity.is_signaling_nan()) { + fputil::raise_except_if_required(FE_INVALID); + if (bitx.is_nan() && bity.is_nan()) + return FPBits::quiet_nan().get_val(); + } + if (bitx.is_nan()) + return y; + if (bity.is_nan()) + return x; + if (bitx.sign() != bity.sign()) + return (bitx.is_neg() ? x : y); + return x < y ? x : y; +} + +template , int> = 0> +LIBC_INLINE T fmaximum_mag(T x, T y) { + FPBits bitx(x), bity(y); + + if (abs(x) > abs(y)) + return x; + if (abs(y) > abs(x)) + return y; + return fmaximum(x, y); +} + +template , int> = 0> +LIBC_INLINE T fminimum_mag(T x, T y) { + FPBits bitx(x), bity(y); + + if (abs(x) < abs(y)) + return x; + if (abs(y) < abs(x)) + return y; + return fminimum(x, y); +} + +template , int> = 0> +LIBC_INLINE T fmaximum_mag_num(T x, T y) { + FPBits bitx(x), bity(y); + + if (abs(x) > abs(y)) + return x; + if (abs(y) > abs(x)) + return y; + return fmaximum_num(x, y); +} + +template , int> = 0> +LIBC_INLINE T fminimum_mag_num(T x, T y) { + FPBits bitx(x), bity(y); + + if (abs(x) < abs(y)) + return x; + if (abs(y) < abs(x)) + return y; + return fminimum_num(x, y); +} + template , int> = 0> LIBC_INLINE T fdim(T x, T y) { FPBits bitx(x), bity(y); diff --git a/libc/src/math/CMakeLists.txt b/libc/src/math/CMakeLists.txt index 2f1d65780013f8..61baa498321cb1 100644 --- a/libc/src/math/CMakeLists.txt +++ b/libc/src/math/CMakeLists.txt @@ -117,6 +117,46 @@ add_math_entrypoint_object(fminf) add_math_entrypoint_object(fminl) add_math_entrypoint_object(fminf128) +add_math_entrypoint_object(fmaximum) +add_math_entrypoint_object(fmaximumf) +add_math_entrypoint_object(fmaximuml) +add_math_entrypoint_object(fmaximumf128) + +add_math_entrypoint_object(fmaximum_num) +add_math_entrypoint_object(fmaximum_numf) +add_math_entrypoint_object(fmaximum_numl) +add_math_entrypoint_object(fmaximum_numf128) + +add_math_entrypoint_object(fmaximum_mag) +add_math_entrypoint_object(fmaximum_magf) +add_math_entrypoint_object(fmaximum_magl) +add_math_entrypoint_object(fmaximum_magf128) + +add_math_entrypoint_object(fmaximum_mag_num) +add_math_entrypoint_object(fmaximum_mag_numf) +add_math_entrypoint_object(fmaximum_mag_numl) +add_math_entrypoint_object(fmaximum_mag_numf128) + +add_math_entrypoint_object(fminimum) +add_math_entrypoint_object(fminimumf) +add_math_entrypoint_object(fminimuml) +add_math_entrypoint_object(fminimumf128) + +add_math_entrypoint_object(fminimum_num) +add_math_entrypoint_object(fminimum_numf) +add_math_entrypoint_object(fminimum_numl) +add_math_entrypoint_object(fminimum_numf128) + +add_math_entrypoint_object(fminimum_mag) +add_math_entrypoint_object(fminimum_magf) +add_math_entrypoint_object(fminimum_magl) +add_math_entrypoint_object(fminimum_magf128) + +add_math_entrypoint_object(fminimum_mag_num) +add_math_entrypoint_object(fminimum_mag_numf) +add_math_entrypoint_object(fminimum_mag_numl) +add_math_entrypoint_object(fminimum_mag_numf128) + add_math_entrypoint_object(fmod) add_math_entrypoint_object(fmodf) add_math_entrypoint_object(fmodl) diff --git a/libc/src/math/fmaximum.h b/libc/src/math/fmaximum.h new file mode 100644 index 00000000000000..8eac02b17b79ab --- /dev/null +++ b/libc/src/math/fmaximum.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum --------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_H + +namespace LIBC_NAMESPACE { + +double fmaximum(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_H diff --git a/libc/src/math/fmaximum_mag.h b/libc/src/math/fmaximum_mag.h new file mode 100644 index 00000000000000..31b7c0fcf7ee3e --- /dev/null +++ b/libc/src/math/fmaximum_mag.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_mag------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_H + +namespace LIBC_NAMESPACE { + +double fmaximum_mag(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_H diff --git a/libc/src/math/fmaximum_mag_num.h b/libc/src/math/fmaximum_mag_num.h new file mode 100644 index 00000000000000..c4ff243846e037 --- /dev/null +++ b/libc/src/math/fmaximum_mag_num.h @@ -0,0 +1,18 @@ +//===-- Implementation header for fmaximum_mag_num---------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUM_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUM_H + +namespace LIBC_NAMESPACE { + +double fmaximum_mag_num(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUM_H diff --git a/libc/src/math/fmaximum_mag_numf.h b/libc/src/math/fmaximum_mag_numf.h new file mode 100644 index 00000000000000..702903ab8bcfe3 --- /dev/null +++ b/libc/src/math/fmaximum_mag_numf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_mag_numf ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUMF_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUMF_H + +namespace LIBC_NAMESPACE { + +float fmaximum_mag_numf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUMF_H diff --git a/libc/src/math/fmaximum_mag_numf128.h b/libc/src/math/fmaximum_mag_numf128.h new file mode 100644 index 00000000000000..2afae7fc37c46a --- /dev/null +++ b/libc/src/math/fmaximum_mag_numf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fmaximum_mag_numf128 -------------------*- C++ +// -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUMF128_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUMF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fmaximum_mag_numf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUMF128_H diff --git a/libc/src/math/fmaximum_mag_numl.h b/libc/src/math/fmaximum_mag_numl.h new file mode 100644 index 00000000000000..32f9ae9708a655 --- /dev/null +++ b/libc/src/math/fmaximum_mag_numl.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_mag_numl ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUML_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUML_H + +namespace LIBC_NAMESPACE { + +long double fmaximum_mag_numl(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAG_NUML_H diff --git a/libc/src/math/fmaximum_magf.h b/libc/src/math/fmaximum_magf.h new file mode 100644 index 00000000000000..1bfcc795f8f81c --- /dev/null +++ b/libc/src/math/fmaximum_magf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_magf -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGF_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGF_H + +namespace LIBC_NAMESPACE { + +float fmaximum_magf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGF_H diff --git a/libc/src/math/fmaximum_magf128.h b/libc/src/math/fmaximum_magf128.h new file mode 100644 index 00000000000000..23c466b74cce89 --- /dev/null +++ b/libc/src/math/fmaximum_magf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fmaximum_magf128 ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGF128_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fmaximum_magf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGF128_H diff --git a/libc/src/math/fmaximum_magl.h b/libc/src/math/fmaximum_magl.h new file mode 100644 index 00000000000000..23b283cb5dbc24 --- /dev/null +++ b/libc/src/math/fmaximum_magl.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_magl -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGL_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGL_H + +namespace LIBC_NAMESPACE { + +long double fmaximum_magl(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_MAGL_H diff --git a/libc/src/math/fmaximum_num.h b/libc/src/math/fmaximum_num.h new file mode 100644 index 00000000000000..ce3ce12ca64b4c --- /dev/null +++ b/libc/src/math/fmaximum_num.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_num--------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_NUM_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_NUM_H + +namespace LIBC_NAMESPACE { + +double fmaximum_num(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_NUM_H diff --git a/libc/src/math/fmaximum_numf.h b/libc/src/math/fmaximum_numf.h new file mode 100644 index 00000000000000..b3243ed16be9f0 --- /dev/null +++ b/libc/src/math/fmaximum_numf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_numf -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_NUMF_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_NUMF_H + +namespace LIBC_NAMESPACE { + +float fmaximum_numf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_NUMF_H diff --git a/libc/src/math/fmaximum_numf128.h b/libc/src/math/fmaximum_numf128.h new file mode 100644 index 00000000000000..d55183ce88cc61 --- /dev/null +++ b/libc/src/math/fmaximum_numf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fmaximum_numf128 ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_NUMF128_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_NUMF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fmaximum_numf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_NUMF128_H diff --git a/libc/src/math/fmaximum_numl.h b/libc/src/math/fmaximum_numl.h new file mode 100644 index 00000000000000..f668cbdf73151b --- /dev/null +++ b/libc/src/math/fmaximum_numl.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximum_numl -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUM_NUML_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUM_NUML_H + +namespace LIBC_NAMESPACE { + +long double fmaximum_numl(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUM_NUML_H diff --git a/libc/src/math/fmaximumf.h b/libc/src/math/fmaximumf.h new file mode 100644 index 00000000000000..4eee696ce15217 --- /dev/null +++ b/libc/src/math/fmaximumf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximumf -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUMF_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUMF_H + +namespace LIBC_NAMESPACE { + +float fmaximumf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUMF_H diff --git a/libc/src/math/fmaximumf128.h b/libc/src/math/fmaximumf128.h new file mode 100644 index 00000000000000..4a214ef096e10e --- /dev/null +++ b/libc/src/math/fmaximumf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fmaximumf128 ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUMF128_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUMF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fmaximumf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUMF128_H diff --git a/libc/src/math/fmaximuml.h b/libc/src/math/fmaximuml.h new file mode 100644 index 00000000000000..ba8a8b12110c70 --- /dev/null +++ b/libc/src/math/fmaximuml.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fmaximuml -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMAXIMUML_H +#define LLVM_LIBC_SRC_MATH_FMAXIMUML_H + +namespace LIBC_NAMESPACE { + +long double fmaximuml(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMAXIMUML_H diff --git a/libc/src/math/fminimum.h b/libc/src/math/fminimum.h new file mode 100644 index 00000000000000..9d39b1bdd3db2d --- /dev/null +++ b/libc/src/math/fminimum.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_H + +namespace LIBC_NAMESPACE { + +double fminimum(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_H diff --git a/libc/src/math/fminimum_mag.h b/libc/src/math/fminimum_mag.h new file mode 100644 index 00000000000000..10b242e6026e83 --- /dev/null +++ b/libc/src/math/fminimum_mag.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_mag--------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_H + +namespace LIBC_NAMESPACE { + +double fminimum_mag(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_H diff --git a/libc/src/math/fminimum_mag_num.h b/libc/src/math/fminimum_mag_num.h new file mode 100644 index 00000000000000..eb1823018851c1 --- /dev/null +++ b/libc/src/math/fminimum_mag_num.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_mag_num------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUM_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUM_H + +namespace LIBC_NAMESPACE { + +double fminimum_mag_num(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMH diff --git a/libc/src/math/fminimum_mag_numf.h b/libc/src/math/fminimum_mag_numf.h new file mode 100644 index 00000000000000..80919909113999 --- /dev/null +++ b/libc/src/math/fminimum_mag_numf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_mag_numf ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMF_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMF_H + +namespace LIBC_NAMESPACE { + +float fminimum_mag_numf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMF_H diff --git a/libc/src/math/fminimum_mag_numf128.h b/libc/src/math/fminimum_mag_numf128.h new file mode 100644 index 00000000000000..803c5e641d170c --- /dev/null +++ b/libc/src/math/fminimum_mag_numf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fminimum_mag_numf128 -------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMF128_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fminimum_mag_numf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUMF128_H diff --git a/libc/src/math/fminimum_mag_numl.h b/libc/src/math/fminimum_mag_numl.h new file mode 100644 index 00000000000000..fdbb183280692a --- /dev/null +++ b/libc/src/math/fminimum_mag_numl.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_mag_numl ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUML_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUML_H + +namespace LIBC_NAMESPACE { + +long double fminimum_mag_numl(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAG_NUML_H diff --git a/libc/src/math/fminimum_magf.h b/libc/src/math/fminimum_magf.h new file mode 100644 index 00000000000000..6209340074d2dc --- /dev/null +++ b/libc/src/math/fminimum_magf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_magf -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAGF_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAGF_H + +namespace LIBC_NAMESPACE { + +float fminimum_magf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAGF_H diff --git a/libc/src/math/fminimum_magf128.h b/libc/src/math/fminimum_magf128.h new file mode 100644 index 00000000000000..05bd163be97c81 --- /dev/null +++ b/libc/src/math/fminimum_magf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fminimum_magf128 ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAGF128_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAGF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fminimum_magf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAGF128_H diff --git a/libc/src/math/fminimum_magl.h b/libc/src/math/fminimum_magl.h new file mode 100644 index 00000000000000..bcda35ce3bd2a3 --- /dev/null +++ b/libc/src/math/fminimum_magl.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_magl -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_MAGL_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_MAGL_H + +namespace LIBC_NAMESPACE { + +long double fminimum_magl(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_MAGL_H diff --git a/libc/src/math/fminimum_num.h b/libc/src/math/fminimum_num.h new file mode 100644 index 00000000000000..4c864cba84872e --- /dev/null +++ b/libc/src/math/fminimum_num.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_num--------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_NUM_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_NUM_H + +namespace LIBC_NAMESPACE { + +double fminimum_num(double x, double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_NUM_H diff --git a/libc/src/math/fminimum_numf.h b/libc/src/math/fminimum_numf.h new file mode 100644 index 00000000000000..ac4b08b292be82 --- /dev/null +++ b/libc/src/math/fminimum_numf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_numf -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_NUMF_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_NUMF_H + +namespace LIBC_NAMESPACE { + +float fminimum_numf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_NUMF_H diff --git a/libc/src/math/fminimum_numf128.h b/libc/src/math/fminimum_numf128.h new file mode 100644 index 00000000000000..00f8960ff12797 --- /dev/null +++ b/libc/src/math/fminimum_numf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fminimum_numf128 ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_NUMF128_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_NUMF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fminimum_numf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_NUMF128_H diff --git a/libc/src/math/fminimum_numl.h b/libc/src/math/fminimum_numl.h new file mode 100644 index 00000000000000..0da204e72c74d4 --- /dev/null +++ b/libc/src/math/fminimum_numl.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimum_numl -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUM_NUML_H +#define LLVM_LIBC_SRC_MATH_FMINIMUM_NUML_H + +namespace LIBC_NAMESPACE { + +long double fminimum_numl(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUM_NUML_H diff --git a/libc/src/math/fminimumf.h b/libc/src/math/fminimumf.h new file mode 100644 index 00000000000000..424309f3a5313e --- /dev/null +++ b/libc/src/math/fminimumf.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimumf -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUMF_H +#define LLVM_LIBC_SRC_MATH_FMINIMUMF_H + +namespace LIBC_NAMESPACE { + +float fminimumf(float x, float y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUMF_H diff --git a/libc/src/math/fminimumf128.h b/libc/src/math/fminimumf128.h new file mode 100644 index 00000000000000..7ff0190727379a --- /dev/null +++ b/libc/src/math/fminimumf128.h @@ -0,0 +1,21 @@ +//===-- Implementation header for fminimumf128 ----------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUMF128_H +#define LLVM_LIBC_SRC_MATH_FMINIMUMF128_H + +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE { + +float128 fminimumf128(float128 x, float128 y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUMF128_H diff --git a/libc/src/math/fminimuml.h b/libc/src/math/fminimuml.h new file mode 100644 index 00000000000000..b9cc321354a283 --- /dev/null +++ b/libc/src/math/fminimuml.h @@ -0,0 +1,19 @@ +//===-- Implementation header for fminimuml -------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_FMINIMUML_H +#define LLVM_LIBC_SRC_MATH_FMINIMUML_H + +namespace LIBC_NAMESPACE { + +long double fminimuml(long double x, long double y); + +} // namespace LIBC_NAMESPACE + +#endif // LLVM_LIBC_SRC_MATH_FMINIMUML_H diff --git a/libc/src/math/generic/CMakeLists.txt b/libc/src/math/generic/CMakeLists.txt index 5198e9c58a98f1..60d329f9adc6e3 100644 --- a/libc/src/math/generic/CMakeLists.txt +++ b/libc/src/math/generic/CMakeLists.txt @@ -1545,6 +1545,400 @@ add_entrypoint_object( -O3 ) +add_entrypoint_object( + fmaximum + SRCS + fmaximum.cpp + HDRS + ../fmaximum.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximumf + SRCS + fmaximumf.cpp + HDRS + ../fmaximumf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximuml + SRCS + fmaximuml.cpp + HDRS + ../fmaximuml.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximumf128 + SRCS + fmaximumf128.cpp + HDRS + ../fmaximumf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + +add_entrypoint_object( + fmaximum_num + SRCS + fmaximum_num.cpp + HDRS + ../fmaximum_num.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_numf + SRCS + fmaximum_numf.cpp + HDRS + ../fmaximum_numf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_numl + SRCS + fmaximum_numl.cpp + HDRS + ../fmaximum_numl.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_numf128 + SRCS + fmaximum_numf128.cpp + HDRS + ../fmaximum_numf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + +add_entrypoint_object( + fmaximum_mag + SRCS + fmaximum_mag.cpp + HDRS + ../fmaximum_mag.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_magf + SRCS + fmaximum_magf.cpp + HDRS + ../fmaximum_magf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_magl + SRCS + fmaximum_magl.cpp + HDRS + ../fmaximum_magl.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_magf128 + SRCS + fmaximum_magf128.cpp + HDRS + ../fmaximum_magf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + + +add_entrypoint_object( + fmaximum_mag_num + SRCS + fmaximum_mag_num.cpp + HDRS + ../fmaximum_mag_num.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_mag_numf + SRCS + fmaximum_mag_numf.cpp + HDRS + ../fmaximum_mag_numf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_mag_numl + SRCS + fmaximum_mag_numl.cpp + HDRS + ../fmaximum_mag_numl.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fmaximum_mag_numf128 + SRCS + fmaximum_mag_numf128.cpp + HDRS + ../fmaximum_mag_numf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + +add_entrypoint_object( + fminimum + SRCS + fminimum.cpp + HDRS + ../fminimum.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimumf + SRCS + fminimumf.cpp + HDRS + ../fminimumf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimuml + SRCS + fminimuml.cpp + HDRS + ../fminimuml.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimumf128 + SRCS + fminimumf128.cpp + HDRS + ../fminimumf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + +add_entrypoint_object( + fminimum_num + SRCS + fminimum_num.cpp + HDRS + ../fminimum_num.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_numf + SRCS + fminimum_numf.cpp + HDRS + ../fminimum_numf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_numl + SRCS + fminimum_numl.cpp + HDRS + ../fminimum_numl.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_numf128 + SRCS + fminimum_numf128.cpp + HDRS + ../fminimum_numf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + +add_entrypoint_object( + fminimum_mag + SRCS + fminimum_mag.cpp + HDRS + ../fminimum_mag.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_magf + SRCS + fminimum_magf.cpp + HDRS + ../fminimum_magf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_magl + SRCS + fminimum_magl.cpp + HDRS + ../fminimum_magl.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_magf128 + SRCS + fminimum_magf128.cpp + HDRS + ../fminimum_magf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + + +add_entrypoint_object( + fminimum_mag_num + SRCS + fminimum_mag_num.cpp + HDRS + ../fminimum_mag_num.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_mag_numf + SRCS + fminimum_mag_numf.cpp + HDRS + ../fminimum_mag_numf.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_mag_numl + SRCS + fminimum_mag_numl.cpp + HDRS + ../fminimum_mag_numl.h + DEPENDS + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O2 +) + +add_entrypoint_object( + fminimum_mag_numf128 + SRCS + fminimum_mag_numf128.cpp + HDRS + ../fminimum_mag_numf128.h + DEPENDS + libc.src.__support.macros.properties.types + libc.src.__support.FPUtil.basic_operations + COMPILE_OPTIONS + -O3 +) + add_entrypoint_object( sqrt SRCS @@ -1557,6 +1951,7 @@ add_entrypoint_object( -O3 ) + add_entrypoint_object( sqrtf SRCS diff --git a/libc/src/math/generic/fmaximum.cpp b/libc/src/math/generic/fmaximum.cpp new file mode 100644 index 00000000000000..ac9593b325d4bf --- /dev/null +++ b/libc/src/math/generic/fmaximum.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum function--------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fmaximum, (double x, double y)) { + return fputil::fmaximum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_mag.cpp b/libc/src/math/generic/fmaximum_mag.cpp new file mode 100644 index 00000000000000..0deb0c2835f932 --- /dev/null +++ b/libc/src/math/generic/fmaximum_mag.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_mag function----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_mag.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fmaximum_mag, (double x, double y)) { + return fputil::fmaximum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_mag_num.cpp b/libc/src/math/generic/fmaximum_mag_num.cpp new file mode 100644 index 00000000000000..d0b1096b88bc66 --- /dev/null +++ b/libc/src/math/generic/fmaximum_mag_num.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_mag_num function------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_mag_num.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fmaximum_mag_num, (double x, double y)) { + return fputil::fmaximum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_mag_numf.cpp b/libc/src/math/generic/fmaximum_mag_numf.cpp new file mode 100644 index 00000000000000..672d3fd3b263a4 --- /dev/null +++ b/libc/src/math/generic/fmaximum_mag_numf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_mag_numf function-----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_mag_numf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fmaximum_mag_numf, (float x, float y)) { + return fputil::fmaximum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_mag_numf128.cpp b/libc/src/math/generic/fmaximum_mag_numf128.cpp new file mode 100644 index 00000000000000..e7d13f13a09826 --- /dev/null +++ b/libc/src/math/generic/fmaximum_mag_numf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_mag_numf128 function--------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_mag_numf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fmaximum_mag_numf128, (float128 x, float128 y)) { + return fputil::fmaximum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_mag_numl.cpp b/libc/src/math/generic/fmaximum_mag_numl.cpp new file mode 100644 index 00000000000000..a8499ca473b365 --- /dev/null +++ b/libc/src/math/generic/fmaximum_mag_numl.cpp @@ -0,0 +1,20 @@ +//===-- Implementation of fmaximum_mag_numl function-----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_mag_numl.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fmaximum_mag_numl, + (long double x, long double y)) { + return fputil::fmaximum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_magf.cpp b/libc/src/math/generic/fmaximum_magf.cpp new file mode 100644 index 00000000000000..380aca05a5255c --- /dev/null +++ b/libc/src/math/generic/fmaximum_magf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_magf function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_magf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fmaximum_magf, (float x, float y)) { + return fputil::fmaximum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_magf128.cpp b/libc/src/math/generic/fmaximum_magf128.cpp new file mode 100644 index 00000000000000..301938fb7ffd3e --- /dev/null +++ b/libc/src/math/generic/fmaximum_magf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_magf128 function------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_magf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fmaximum_magf128, (float128 x, float128 y)) { + return fputil::fmaximum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_magl.cpp b/libc/src/math/generic/fmaximum_magl.cpp new file mode 100644 index 00000000000000..283a11eda9aab6 --- /dev/null +++ b/libc/src/math/generic/fmaximum_magl.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_magl function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_magl.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fmaximum_magl, (long double x, long double y)) { + return fputil::fmaximum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_num.cpp b/libc/src/math/generic/fmaximum_num.cpp new file mode 100644 index 00000000000000..23553dbcae7edb --- /dev/null +++ b/libc/src/math/generic/fmaximum_num.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_num function----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_num.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fmaximum_num, (double x, double y)) { + return fputil::fmaximum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_numf.cpp b/libc/src/math/generic/fmaximum_numf.cpp new file mode 100644 index 00000000000000..f946ff43f543ca --- /dev/null +++ b/libc/src/math/generic/fmaximum_numf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_numf function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_numf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fmaximum_numf, (float x, float y)) { + return fputil::fmaximum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_numf128.cpp b/libc/src/math/generic/fmaximum_numf128.cpp new file mode 100644 index 00000000000000..f33a5e195bf25f --- /dev/null +++ b/libc/src/math/generic/fmaximum_numf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_numf128 function------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_numf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fmaximum_numf128, (float128 x, float128 y)) { + return fputil::fmaximum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximum_numl.cpp b/libc/src/math/generic/fmaximum_numl.cpp new file mode 100644 index 00000000000000..503fc41409f683 --- /dev/null +++ b/libc/src/math/generic/fmaximum_numl.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximum_numl function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximum_numl.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fmaximum_numl, (long double x, long double y)) { + return fputil::fmaximum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximumf.cpp b/libc/src/math/generic/fmaximumf.cpp new file mode 100644 index 00000000000000..3b2a60931bf630 --- /dev/null +++ b/libc/src/math/generic/fmaximumf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximumf function-------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximumf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fmaximumf, (float x, float y)) { + return fputil::fmaximum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximumf128.cpp b/libc/src/math/generic/fmaximumf128.cpp new file mode 100644 index 00000000000000..0099c913b05261 --- /dev/null +++ b/libc/src/math/generic/fmaximumf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximumf128 function----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximumf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fmaximumf128, (float128 x, float128 y)) { + return fputil::fmaximum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fmaximuml.cpp b/libc/src/math/generic/fmaximuml.cpp new file mode 100644 index 00000000000000..ecd698300458f1 --- /dev/null +++ b/libc/src/math/generic/fmaximuml.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fmaximuml function-------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fmaximuml.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fmaximuml, (long double x, long double y)) { + return fputil::fmaximum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum.cpp b/libc/src/math/generic/fminimum.cpp new file mode 100644 index 00000000000000..28b257d950f439 --- /dev/null +++ b/libc/src/math/generic/fminimum.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum function--------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fminimum, (double x, double y)) { + return fputil::fminimum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_mag.cpp b/libc/src/math/generic/fminimum_mag.cpp new file mode 100644 index 00000000000000..6af99570e1ea4e --- /dev/null +++ b/libc/src/math/generic/fminimum_mag.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_mag function----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_mag.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fminimum_mag, (double x, double y)) { + return fputil::fminimum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_mag_num.cpp b/libc/src/math/generic/fminimum_mag_num.cpp new file mode 100644 index 00000000000000..fc5431ae279942 --- /dev/null +++ b/libc/src/math/generic/fminimum_mag_num.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_mag_num function------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_mag_num.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fminimum_mag_num, (double x, double y)) { + return fputil::fminimum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_mag_numf.cpp b/libc/src/math/generic/fminimum_mag_numf.cpp new file mode 100644 index 00000000000000..71179a6f03c213 --- /dev/null +++ b/libc/src/math/generic/fminimum_mag_numf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_mag_numf function-----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_mag_numf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fminimum_mag_numf, (float x, float y)) { + return fputil::fminimum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_mag_numf128.cpp b/libc/src/math/generic/fminimum_mag_numf128.cpp new file mode 100644 index 00000000000000..109ce7e4e0111b --- /dev/null +++ b/libc/src/math/generic/fminimum_mag_numf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_mag_numf128 function--------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_mag_numf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fminimum_mag_numf128, (float128 x, float128 y)) { + return fputil::fminimum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_mag_numl.cpp b/libc/src/math/generic/fminimum_mag_numl.cpp new file mode 100644 index 00000000000000..c97ce6ead0425b --- /dev/null +++ b/libc/src/math/generic/fminimum_mag_numl.cpp @@ -0,0 +1,20 @@ +//===-- Implementation of fminimum_mag_numl function-----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_mag_numl.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fminimum_mag_numl, + (long double x, long double y)) { + return fputil::fminimum_mag_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_magf.cpp b/libc/src/math/generic/fminimum_magf.cpp new file mode 100644 index 00000000000000..834f6a4a97101a --- /dev/null +++ b/libc/src/math/generic/fminimum_magf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_magf function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_magf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fminimum_magf, (float x, float y)) { + return fputil::fminimum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_magf128.cpp b/libc/src/math/generic/fminimum_magf128.cpp new file mode 100644 index 00000000000000..2828e28bb0a401 --- /dev/null +++ b/libc/src/math/generic/fminimum_magf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_magf128 function------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_magf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fminimum_magf128, (float128 x, float128 y)) { + return fputil::fminimum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_magl.cpp b/libc/src/math/generic/fminimum_magl.cpp new file mode 100644 index 00000000000000..50e328fd92d1f9 --- /dev/null +++ b/libc/src/math/generic/fminimum_magl.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_magl function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_magl.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fminimum_magl, (long double x, long double y)) { + return fputil::fminimum_mag(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_num.cpp b/libc/src/math/generic/fminimum_num.cpp new file mode 100644 index 00000000000000..e89c7f5acf9b18 --- /dev/null +++ b/libc/src/math/generic/fminimum_num.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_num function----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_num.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(double, fminimum_num, (double x, double y)) { + return fputil::fminimum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_numf.cpp b/libc/src/math/generic/fminimum_numf.cpp new file mode 100644 index 00000000000000..c37c8bd423a1a6 --- /dev/null +++ b/libc/src/math/generic/fminimum_numf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_numf function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_numf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fminimum_numf, (float x, float y)) { + return fputil::fminimum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_numf128.cpp b/libc/src/math/generic/fminimum_numf128.cpp new file mode 100644 index 00000000000000..6b1f77bb447cf8 --- /dev/null +++ b/libc/src/math/generic/fminimum_numf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_numf128 function------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_numf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fminimum_numf128, (float128 x, float128 y)) { + return fputil::fminimum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimum_numl.cpp b/libc/src/math/generic/fminimum_numl.cpp new file mode 100644 index 00000000000000..22045f83f2a733 --- /dev/null +++ b/libc/src/math/generic/fminimum_numl.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimum_numl function---------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimum_numl.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fminimum_numl, (long double x, long double y)) { + return fputil::fminimum_num(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimumf.cpp b/libc/src/math/generic/fminimumf.cpp new file mode 100644 index 00000000000000..c937fb0ea01d0d --- /dev/null +++ b/libc/src/math/generic/fminimumf.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimumf function-------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimumf.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float, fminimumf, (float x, float y)) { + return fputil::fminimum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimumf128.cpp b/libc/src/math/generic/fminimumf128.cpp new file mode 100644 index 00000000000000..24e02b8ff537f0 --- /dev/null +++ b/libc/src/math/generic/fminimumf128.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimumf128 function----------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimumf128.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(float128, fminimumf128, (float128 x, float128 y)) { + return fputil::fminimum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/src/math/generic/fminimuml.cpp b/libc/src/math/generic/fminimuml.cpp new file mode 100644 index 00000000000000..43319503661aae --- /dev/null +++ b/libc/src/math/generic/fminimuml.cpp @@ -0,0 +1,19 @@ +//===-- Implementation of fminimuml function-------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/fminimuml.h" +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/common.h" + +namespace LIBC_NAMESPACE { + +LLVM_LIBC_FUNCTION(long double, fminimuml, (long double x, long double y)) { + return fputil::fminimum(x, y); +} + +} // namespace LIBC_NAMESPACE diff --git a/libc/test/src/math/smoke/CMakeLists.txt b/libc/test/src/math/smoke/CMakeLists.txt index 56d864e7808310..1345dca08a6a95 100644 --- a/libc/test/src/math/smoke/CMakeLists.txt +++ b/libc/test/src/math/smoke/CMakeLists.txt @@ -1477,6 +1477,424 @@ add_fp_unittest( libc.src.__support.FPUtil.fp_bits ) +add_fp_unittest( + fmaximuml_test + SUITE + libc-math-smoke-tests + SRCS + fmaximuml_test.cpp + HDRS + FMaximumTest.h + DEPENDS + libc.src.math.fmaximuml + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximumf128_test + SUITE + libc-math-smoke-tests + SRCS + fmaximumf128_test.cpp + HDRS + FMaximumTest.h + DEPENDS + libc.src.math.fmaximumf128 + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_test.cpp + HDRS + FMaximumTest.h + DEPENDS + libc.src.math.fmaximum + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximumf_test + SUITE + libc-math-smoke-tests + SRCS + fmaximumf_test.cpp + HDRS + FMaximumTest.h + DEPENDS + libc.src.math.fmaximumf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_numf_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_numf_test.cpp + HDRS + FMaximumNumTest.h + DEPENDS + libc.src.math.fmaximum_numf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_num_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_num_test.cpp + HDRS + FMaximumNumTest.h + DEPENDS + libc.src.math.fmaximum_num + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_numl_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_numl_test.cpp + HDRS + FMaximumNumTest.h + DEPENDS + libc.src.math.fmaximum_numl + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_numf128_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_numf128_test.cpp + HDRS + FMaximumNumTest.h + DEPENDS + libc.src.math.fmaximum_numf128 + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_magf_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_magf_test.cpp + HDRS + FMaximumMagTest.h + DEPENDS + libc.src.math.fmaximum_magf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_mag_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_mag_test.cpp + HDRS + FMaximumMagTest.h + DEPENDS + libc.src.math.fmaximum_mag + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_magl_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_magl_test.cpp + HDRS + FMaximumMagTest.h + DEPENDS + libc.src.math.fmaximum_magl + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_magf128_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_magf128_test.cpp + HDRS + FMaximumMagTest.h + DEPENDS + libc.src.math.fmaximum_magf128 + libc.src.__support.FPUtil.fp_bits +) + + +add_fp_unittest( + fmaximum_mag_numf_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_mag_numf_test.cpp + HDRS + FMaximumMagNumTest.h + DEPENDS + libc.src.math.fmaximum_mag_numf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_mag_num_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_mag_num_test.cpp + HDRS + FMaximumMagNumTest.h + DEPENDS + libc.src.math.fmaximum_mag_num + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_mag_numl_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_mag_numl_test.cpp + HDRS + FMaximumMagNumTest.h + DEPENDS + libc.src.math.fmaximum_mag_numl + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fmaximum_mag_numf128_test + SUITE + libc-math-smoke-tests + SRCS + fmaximum_mag_numf128_test.cpp + HDRS + FMaximumMagNumTest.h + DEPENDS + libc.src.math.fmaximum_mag_numf128 + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimuml_test + SUITE + libc-math-smoke-tests + SRCS + fminimuml_test.cpp + HDRS + FMinimumTest.h + DEPENDS + libc.src.math.fminimuml + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimumf128_test + SUITE + libc-math-smoke-tests + SRCS + fminimumf128_test.cpp + HDRS + FMinimumTest.h + DEPENDS + libc.src.math.fminimumf128 + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_test.cpp + HDRS + FMinimumTest.h + DEPENDS + libc.src.math.fminimum + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimumf_test + SUITE + libc-math-smoke-tests + SRCS + fminimumf_test.cpp + HDRS + FMinimumTest.h + DEPENDS + libc.src.math.fminimumf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_numf_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_numf_test.cpp + HDRS + FMinimumNumTest.h + DEPENDS + libc.src.math.fminimum_numf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_num_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_num_test.cpp + HDRS + FMinimumNumTest.h + DEPENDS + libc.src.math.fminimum_num + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_numl_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_numl_test.cpp + HDRS + FMinimumNumTest.h + DEPENDS + libc.src.math.fminimum_numl + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_numf128_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_numf128_test.cpp + HDRS + FMinimumNumTest.h + DEPENDS + libc.src.math.fminimum_numf128 + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_magf_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_magf_test.cpp + HDRS + FMinimumMagTest.h + DEPENDS + libc.src.math.fminimum_magf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_mag_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_mag_test.cpp + HDRS + FMinimumMagTest.h + DEPENDS + libc.src.math.fminimum_mag + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_magl_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_magl_test.cpp + HDRS + FMinimumMagTest.h + DEPENDS + libc.src.math.fminimum_magl + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_magf128_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_magf128_test.cpp + HDRS + FMinimumMagTest.h + DEPENDS + libc.src.math.fminimum_magf128 + libc.src.__support.FPUtil.fp_bits +) + + +add_fp_unittest( + fminimum_mag_numf_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_mag_numf_test.cpp + HDRS + FMinimumMagNumTest.h + DEPENDS + libc.src.math.fminimum_mag_numf + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_mag_num_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_mag_num_test.cpp + HDRS + FMinimumMagNumTest.h + DEPENDS + libc.src.math.fminimum_mag_num + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_mag_numl_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_mag_numl_test.cpp + HDRS + FMinimumMagNumTest.h + DEPENDS + libc.src.math.fminimum_mag_numl + libc.src.__support.FPUtil.fp_bits +) + +add_fp_unittest( + fminimum_mag_numf128_test + SUITE + libc-math-smoke-tests + SRCS + fminimum_mag_numf128_test.cpp + HDRS + FMinimumMagNumTest.h + DEPENDS + libc.src.math.fminimum_mag_numf128 + libc.src.__support.FPUtil.fp_bits +) + add_fp_unittest( sqrtf_test SUITE diff --git a/libc/test/src/math/smoke/FMaximumMagNumTest.h b/libc/test/src/math/smoke/FMaximumMagNumTest.h new file mode 100644 index 00000000000000..715dd4ed913f83 --- /dev/null +++ b/libc/test/src/math/smoke/FMaximumMagNumTest.h @@ -0,0 +1,101 @@ +//===-- Utility class to test fmaximum_mag_num[f|l] -------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMMAG_NUMTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMMAG_NUMTEST_H + +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/FPUtil/FPBits.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMaximumMagNumTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMaximumMagNumFunc)(T, T); + + void testNaN(FMaximumMagNumFunc func) { + EXPECT_FP_EQ(inf, func(aNaN, inf)); + EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(sNaN, inf), FE_INVALID); + EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(neg_inf, sNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, aNaN)).uintval()); + EXPECT_FP_EQ(0.0, func(aNaN, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(0.0, func(sNaN, 0.0), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(-0.0, func(-0.0, sNaN), FE_INVALID); + EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(T(-1.2345), func(sNaN, T(-1.2345)), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(T(1.2345), func(T(1.2345), sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(aNaN, sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(sNaN, aNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, sNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, aNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, sNaN)).uintval()); + } + + void testInfArg(FMaximumMagNumFunc func) { + EXPECT_FP_EQ(inf, func(neg_inf, inf)); + EXPECT_FP_EQ(inf, func(inf, 0.0)); + EXPECT_FP_EQ(inf, func(-0.0, inf)); + EXPECT_FP_EQ(inf, func(inf, T(1.2345))); + EXPECT_FP_EQ(inf, func(T(-1.2345), inf)); + } + + void testNegInfArg(FMaximumMagNumFunc func) { + EXPECT_FP_EQ(inf, func(inf, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0)); + EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf)); + } + + void testBothZero(FMaximumMagNumFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMaximumMagNumFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (LIBC_NAMESPACE::fputil::abs(x) > LIBC_NAMESPACE::fputil::abs(y)) { + EXPECT_FP_EQ(x, func(x, y)); + } else { + EXPECT_FP_EQ(y, func(x, y)); + } + } + } +}; + +#define LIST_FMAXIMUM_MAG_NUM_TESTS(T, func) \ + using LlvmLibcFMaximumMagNumTest = FMaximumMagNumTest; \ + TEST_F(LlvmLibcFMaximumMagNumTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMaximumMagNumTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumMagNumTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumMagNumTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMaximumMagNumTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMMAG_NUMTEST_H diff --git a/libc/test/src/math/smoke/FMaximumMagTest.h b/libc/test/src/math/smoke/FMaximumMagTest.h new file mode 100644 index 00000000000000..38276e0fe2fdb0 --- /dev/null +++ b/libc/test/src/math/smoke/FMaximumMagTest.h @@ -0,0 +1,89 @@ +//===-- Utility class to test fmaximum_mag[f|l] -----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUM_MAGTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUM_MAGTEST_H + +#include "src/__support/FPUtil/BasicOperations.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMaximumMagTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMaximumMagFunc)(T, T); + + void testNaN(FMaximumMagFunc func) { + EXPECT_FP_EQ(aNaN, func(aNaN, inf)); + EXPECT_FP_EQ(aNaN, func(neg_inf, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, 0.0)); + EXPECT_FP_EQ(aNaN, func(-0.0, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(aNaN, func(T(1.2345), aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, aNaN)); + } + + void testInfArg(FMaximumMagFunc func) { + EXPECT_FP_EQ(inf, func(neg_inf, inf)); + EXPECT_FP_EQ(inf, func(inf, 0.0)); + EXPECT_FP_EQ(inf, func(-0.0, inf)); + EXPECT_FP_EQ(inf, func(inf, T(1.2345))); + EXPECT_FP_EQ(inf, func(T(-1.2345), inf)); + } + + void testNegInfArg(FMaximumMagFunc func) { + EXPECT_FP_EQ(inf, func(inf, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0)); + EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf)); + } + + void testBothZero(FMaximumMagFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMaximumMagFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (LIBC_NAMESPACE::fputil::abs(x) > LIBC_NAMESPACE::fputil::abs(y)) { + EXPECT_FP_EQ(x, func(x, y)); + } else { + EXPECT_FP_EQ(y, func(x, y)); + } + } + } +}; + +#define LIST_FMAXIMUM_MAG_TESTS(T, func) \ + using LlvmLibcFMaximumMagTest = FMaximumMagTest; \ + TEST_F(LlvmLibcFMaximumMagTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMaximumMagTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumMagTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumMagTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMaximumMagTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUM_MAGTEST_H diff --git a/libc/test/src/math/smoke/FMaximumNumTest.h b/libc/test/src/math/smoke/FMaximumNumTest.h new file mode 100644 index 00000000000000..57096f6b614a2c --- /dev/null +++ b/libc/test/src/math/smoke/FMaximumNumTest.h @@ -0,0 +1,100 @@ +//===-- Utility class to test fmaximum_num[f|l] -----------------*- C++ -*-===// +// +// Part Of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMNUMTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMNUMTEST_H + +#include "src/__support/FPUtil/FPBits.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMaximumNumTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMaximumNumFunc)(T, T); + + void testNaN(FMaximumNumFunc func) { + EXPECT_FP_EQ(inf, func(aNaN, inf)); + EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(sNaN, inf), FE_INVALID); + EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(neg_inf, sNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, aNaN)).uintval()); + EXPECT_FP_EQ(0.0, func(aNaN, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(0.0, func(sNaN, 0.0), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(-0.0, func(-0.0, sNaN), FE_INVALID); + EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(T(-1.2345), func(sNaN, T(-1.2345)), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(T(1.2345), func(T(1.2345), sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(aNaN, sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(sNaN, aNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, sNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, aNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, sNaN)).uintval()); + } + + void testInfArg(FMaximumNumFunc func) { + EXPECT_FP_EQ(inf, func(neg_inf, inf)); + EXPECT_FP_EQ(inf, func(inf, 0.0)); + EXPECT_FP_EQ(inf, func(-0.0, inf)); + EXPECT_FP_EQ(inf, func(inf, T(1.2345))); + EXPECT_FP_EQ(inf, func(T(-1.2345), inf)); + } + + void testNegInfArg(FMaximumNumFunc func) { + EXPECT_FP_EQ(inf, func(inf, neg_inf)); + EXPECT_FP_EQ(0.0, func(neg_inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, neg_inf)); + EXPECT_FP_EQ(T(-1.2345), func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), neg_inf)); + } + + void testBothZero(FMaximumNumFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMaximumNumFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (x > y) { + EXPECT_FP_EQ(x, func(x, y)); + } else { + EXPECT_FP_EQ(y, func(x, y)); + } + } + } +}; + +#define LIST_FMAXIMUM_NUM_TESTS(T, func) \ + using LlvmLibcFMaximumNumTest = FMaximumNumTest; \ + TEST_F(LlvmLibcFMaximumNumTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMaximumNumTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumNumTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumNumTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMaximumNumTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMNUMTEST_H diff --git a/libc/test/src/math/smoke/FMaximumTest.h b/libc/test/src/math/smoke/FMaximumTest.h new file mode 100644 index 00000000000000..4db8bb93baaeef --- /dev/null +++ b/libc/test/src/math/smoke/FMaximumTest.h @@ -0,0 +1,88 @@ +//===-- Utility class to test fmaximum[f|l] ---------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMTEST_H + +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMaximumTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMaximumFunc)(T, T); + + void testNaN(FMaximumFunc func) { + EXPECT_FP_EQ(aNaN, func(aNaN, inf)); + EXPECT_FP_EQ(aNaN, func(neg_inf, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, 0.0)); + EXPECT_FP_EQ(aNaN, func(-0.0, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(aNaN, func(T(1.2345), aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, aNaN)); + } + + void testInfArg(FMaximumFunc func) { + EXPECT_FP_EQ(inf, func(neg_inf, inf)); + EXPECT_FP_EQ(inf, func(inf, 0.0)); + EXPECT_FP_EQ(inf, func(-0.0, inf)); + EXPECT_FP_EQ(inf, func(inf, T(1.2345))); + EXPECT_FP_EQ(inf, func(T(-1.2345), inf)); + } + + void testNegInfArg(FMaximumFunc func) { + EXPECT_FP_EQ(inf, func(inf, neg_inf)); + EXPECT_FP_EQ(0.0, func(neg_inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, neg_inf)); + EXPECT_FP_EQ(T(-1.2345), func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), neg_inf)); + } + + void testBothZero(FMaximumFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMaximumFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (x > y) { + EXPECT_FP_EQ(x, func(x, y)); + } else { + EXPECT_FP_EQ(y, func(x, y)); + } + } + } +}; + +#define LIST_FMAXIMUM_TESTS(T, func) \ + using LlvmLibcFMaximumTest = FMaximumTest; \ + TEST_F(LlvmLibcFMaximumTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMaximumTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMaximumTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMaximumTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMAXIMUMTEST_H diff --git a/libc/test/src/math/smoke/FMinimumMagNumTest.h b/libc/test/src/math/smoke/FMinimumMagNumTest.h new file mode 100644 index 00000000000000..dec8b70740ca59 --- /dev/null +++ b/libc/test/src/math/smoke/FMinimumMagNumTest.h @@ -0,0 +1,101 @@ +//===-- Utility class to test fminimum_mag_num[f|l] -------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMMAG_NUMTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMMAG_NUMTEST_H + +#include "src/__support/FPUtil/BasicOperations.h" +#include "src/__support/FPUtil/FPBits.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMinimumMagNumTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMinimumMagNumFunc)(T, T); + + void testNaN(FMinimumMagNumFunc func) { + EXPECT_FP_EQ(inf, func(aNaN, inf)); + EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(sNaN, inf), FE_INVALID); + EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(neg_inf, sNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, aNaN)).uintval()); + EXPECT_FP_EQ(0.0, func(aNaN, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(0.0, func(sNaN, 0.0), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(-0.0, func(-0.0, sNaN), FE_INVALID); + EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(T(-1.2345), func(sNaN, T(-1.2345)), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(T(1.2345), func(T(1.2345), sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(aNaN, sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(sNaN, aNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, sNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, aNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, sNaN)).uintval()); + } + + void testInfArg(FMinimumMagNumFunc func) { + EXPECT_FP_EQ(neg_inf, func(neg_inf, inf)); + EXPECT_FP_EQ(0.0, func(inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, inf)); + EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345))); + EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf)); + } + + void testNegInfArg(FMinimumMagNumFunc func) { + EXPECT_FP_EQ(neg_inf, func(inf, neg_inf)); + EXPECT_FP_EQ(0.0, func(neg_inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, neg_inf)); + EXPECT_FP_EQ(T(-1.2345), func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), neg_inf)); + } + + void testBothZero(FMinimumMagNumFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMinimumMagNumFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (LIBC_NAMESPACE::fputil::abs(x) > LIBC_NAMESPACE::fputil::abs(y)) { + EXPECT_FP_EQ(y, func(x, y)); + } else { + EXPECT_FP_EQ(x, func(x, y)); + } + } + } +}; + +#define LIST_FMINIMUM_MAG_NUM_TESTS(T, func) \ + using LlvmLibcFMinimumMagNumTest = FMinimumMagNumTest; \ + TEST_F(LlvmLibcFMinimumMagNumTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMinimumMagNumTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumMagNumTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumMagNumTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMinimumMagNumTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMMAG_NUMTEST_H diff --git a/libc/test/src/math/smoke/FMinimumMagTest.h b/libc/test/src/math/smoke/FMinimumMagTest.h new file mode 100644 index 00000000000000..b11092e5379ba0 --- /dev/null +++ b/libc/test/src/math/smoke/FMinimumMagTest.h @@ -0,0 +1,89 @@ +//===-- Utility class to test fminimum_mag[f|l] -----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUM_MAGTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUM_MAGTEST_H + +#include "src/__support/FPUtil/BasicOperations.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMinimumMagTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMinimumMagFunc)(T, T); + + void testNaN(FMinimumMagFunc func) { + EXPECT_FP_EQ(aNaN, func(aNaN, inf)); + EXPECT_FP_EQ(aNaN, func(neg_inf, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, 0.0)); + EXPECT_FP_EQ(aNaN, func(-0.0, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(aNaN, func(T(1.2345), aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, aNaN)); + } + + void testInfArg(FMinimumMagFunc func) { + EXPECT_FP_EQ(neg_inf, func(neg_inf, inf)); + EXPECT_FP_EQ(0.0, func(inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, inf)); + EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345))); + EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf)); + } + + void testNegInfArg(FMinimumMagFunc func) { + EXPECT_FP_EQ(neg_inf, func(inf, neg_inf)); + EXPECT_FP_EQ(0.0, func(neg_inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, neg_inf)); + EXPECT_FP_EQ(T(-1.2345), func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), neg_inf)); + } + + void testBothZero(FMinimumMagFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMinimumMagFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (LIBC_NAMESPACE::fputil::abs(x) < LIBC_NAMESPACE::fputil::abs(y)) { + EXPECT_FP_EQ(x, func(x, y)); + } else { + EXPECT_FP_EQ(y, func(x, y)); + } + } + } +}; + +#define LIST_FMINIMUM_MAG_TESTS(T, func) \ + using LlvmLibcFMinimumMagTest = FMinimumMagTest; \ + TEST_F(LlvmLibcFMinimumMagTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMinimumMagTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumMagTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumMagTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMinimumMagTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUM_MAGTEST_H diff --git a/libc/test/src/math/smoke/FMinimumNumTest.h b/libc/test/src/math/smoke/FMinimumNumTest.h new file mode 100644 index 00000000000000..7fcc291b4c00cd --- /dev/null +++ b/libc/test/src/math/smoke/FMinimumNumTest.h @@ -0,0 +1,100 @@ +//===-- Utility class to test fminimum_num[f|l] -----------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMNUMTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMNUMTEST_H + +#include "src/__support/FPUtil/FPBits.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMinimumNumTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMinimumNumFunc)(T, T); + + void testNaN(FMinimumNumFunc func) { + EXPECT_FP_EQ(inf, func(aNaN, inf)); + EXPECT_FP_EQ_WITH_EXCEPTION(inf, func(sNaN, inf), FE_INVALID); + EXPECT_FP_EQ(neg_inf, func(neg_inf, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(neg_inf, func(neg_inf, sNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, aNaN)).uintval()); + EXPECT_FP_EQ(0.0, func(aNaN, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(0.0, func(sNaN, 0.0), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(-0.0, func(-0.0, sNaN), FE_INVALID); + EXPECT_FP_EQ(T(-1.2345), func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), aNaN)); + EXPECT_FP_EQ_WITH_EXCEPTION(T(-1.2345), func(sNaN, T(-1.2345)), FE_INVALID); + EXPECT_FP_EQ_WITH_EXCEPTION(T(1.2345), func(T(1.2345), sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(aNaN, sNaN), FE_INVALID); + EXPECT_FP_IS_NAN_WITH_EXCEPTION(func(sNaN, aNaN), FE_INVALID); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(aNaN, sNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, aNaN)).uintval()); + EXPECT_EQ(FPBits(aNaN).uintval(), FPBits(func(sNaN, sNaN)).uintval()); + } + + void testInfArg(FMinimumNumFunc func) { + EXPECT_FP_EQ(neg_inf, func(neg_inf, inf)); + EXPECT_FP_EQ(0.0, func(inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, inf)); + EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345))); + EXPECT_FP_EQ(T(-1.2345), func(T(-1.2345), inf)); + } + + void testNegInfArg(FMinimumNumFunc func) { + EXPECT_FP_EQ(neg_inf, func(inf, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0)); + EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf)); + } + + void testBothZero(FMinimumNumFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMinimumNumFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (x > y) { + EXPECT_FP_EQ(y, func(x, y)); + } else { + EXPECT_FP_EQ(x, func(x, y)); + } + } + } +}; + +#define LIST_FMINIMUM_NUM_TESTS(T, func) \ + using LlvmLibcFMinimumNumTest = FMinimumNumTest; \ + TEST_F(LlvmLibcFMinimumNumTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMinimumNumTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumNumTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumNumTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMinimumNumTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMNUMTEST_H diff --git a/libc/test/src/math/smoke/FMinimumTest.h b/libc/test/src/math/smoke/FMinimumTest.h new file mode 100644 index 00000000000000..bc04a6d9935654 --- /dev/null +++ b/libc/test/src/math/smoke/FMinimumTest.h @@ -0,0 +1,88 @@ +//===-- Utility class to test fminimum[f|l] ---------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMTEST_H +#define LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMTEST_H + +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +template +class FMinimumTest : public LIBC_NAMESPACE::testing::Test { + + DECLARE_SPECIAL_CONSTANTS(T) + +public: + typedef T (*FMinimumFunc)(T, T); + + void testNaN(FMinimumFunc func) { + EXPECT_FP_EQ(aNaN, func(aNaN, inf)); + EXPECT_FP_EQ(aNaN, func(neg_inf, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, 0.0)); + EXPECT_FP_EQ(aNaN, func(-0.0, aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, T(-1.2345))); + EXPECT_FP_EQ(aNaN, func(T(1.2345), aNaN)); + EXPECT_FP_EQ(aNaN, func(aNaN, aNaN)); + } + + void testInfArg(FMinimumFunc func) { + EXPECT_FP_EQ(neg_inf, func(neg_inf, inf)); + EXPECT_FP_EQ(0.0, func(inf, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, inf)); + EXPECT_FP_EQ(T(1.2345), func(inf, T(1.2345))); + EXPECT_FP_EQ(T(1.2345), func(T(1.2345), inf)); + } + + void testNegInfArg(FMinimumFunc func) { + EXPECT_FP_EQ(neg_inf, func(inf, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, 0.0)); + EXPECT_FP_EQ(neg_inf, func(-0.0, neg_inf)); + EXPECT_FP_EQ(neg_inf, func(neg_inf, T(-1.2345))); + EXPECT_FP_EQ(neg_inf, func(T(1.2345), neg_inf)); + } + + void testBothZero(FMinimumFunc func) { + EXPECT_FP_EQ(0.0, func(0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, 0.0)); + EXPECT_FP_EQ(-0.0, func(0.0, -0.0)); + EXPECT_FP_EQ(-0.0, func(-0.0, -0.0)); + } + + void testRange(FMinimumFunc func) { + constexpr StorageType COUNT = 100'001; + constexpr StorageType STEP = STORAGE_MAX / COUNT; + for (StorageType i = 0, v = 0, w = STORAGE_MAX; i <= COUNT; + ++i, v += STEP, w -= STEP) { + FPBits xbits(v), ybits(w); + if (xbits.is_inf_or_nan()) + continue; + if (ybits.is_inf_or_nan()) + continue; + T x = xbits.get_val(); + T y = ybits.get_val(); + if ((x == 0) && (y == 0)) + continue; + + if (x > y) { + EXPECT_FP_EQ(y, func(x, y)); + } else { + EXPECT_FP_EQ(x, func(x, y)); + } + } + } +}; + +#define LIST_FMINIMUM_TESTS(T, func) \ + using LlvmLibcFMinimumTest = FMinimumTest; \ + TEST_F(LlvmLibcFMinimumTest, NaN) { testNaN(&func); } \ + TEST_F(LlvmLibcFMinimumTest, InfArg) { testInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumTest, NegInfArg) { testNegInfArg(&func); } \ + TEST_F(LlvmLibcFMinimumTest, BothZero) { testBothZero(&func); } \ + TEST_F(LlvmLibcFMinimumTest, Range) { testRange(&func); } + +#endif // LLVM_LIBC_TEST_SRC_MATH_SMOKE_FMINIMUMTEST_H diff --git a/libc/test/src/math/smoke/fmaximum_mag_num_test.cpp b/libc/test/src/math/smoke/fmaximum_mag_num_test.cpp new file mode 100644 index 00000000000000..16ec1b0ea3437e --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_mag_num_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_mag_num-------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMaximumMagNumTest.h" + +#include "src/math/fmaximum_mag_num.h" + +LIST_FMAXIMUM_MAG_NUM_TESTS(double, LIBC_NAMESPACE::fmaximum_mag_num) diff --git a/libc/test/src/math/smoke/fmaximum_mag_numf128_test.cpp b/libc/test/src/math/smoke/fmaximum_mag_numf128_test.cpp new file mode 100644 index 00000000000000..17f2a24f7fd04e --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_mag_numf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_mag_numf128---------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumMagNumTest.h" + +#include "src/math/fmaximum_mag_numf128.h" + +LIST_FMAXIMUM_MAG_NUM_TESTS(float128, LIBC_NAMESPACE::fmaximum_mag_numf128) diff --git a/libc/test/src/math/smoke/fmaximum_mag_numf_test.cpp b/libc/test/src/math/smoke/fmaximum_mag_numf_test.cpp new file mode 100644 index 00000000000000..a8a46f96970ed6 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_mag_numf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_mag_numf------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumMagNumTest.h" + +#include "src/math/fmaximum_mag_numf.h" + +LIST_FMAXIMUM_MAG_NUM_TESTS(float, LIBC_NAMESPACE::fmaximum_mag_numf) diff --git a/libc/test/src/math/smoke/fmaximum_mag_numl_test.cpp b/libc/test/src/math/smoke/fmaximum_mag_numl_test.cpp new file mode 100644 index 00000000000000..c03fa20bd367e7 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_mag_numl_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_mag_numl------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumMagNumTest.h" + +#include "src/math/fmaximum_mag_numl.h" + +LIST_FMAXIMUM_MAG_NUM_TESTS(long double, LIBC_NAMESPACE::fmaximum_mag_numl) diff --git a/libc/test/src/math/smoke/fmaximum_mag_test.cpp b/libc/test/src/math/smoke/fmaximum_mag_test.cpp new file mode 100644 index 00000000000000..e70602f044ec69 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_mag_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_mag-----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMaximumMagTest.h" + +#include "src/math/fmaximum_mag.h" + +LIST_FMAXIMUM_MAG_TESTS(double, LIBC_NAMESPACE::fmaximum_mag) diff --git a/libc/test/src/math/smoke/fmaximum_magf128_test.cpp b/libc/test/src/math/smoke/fmaximum_magf128_test.cpp new file mode 100644 index 00000000000000..d7ae8ec8d7a03f --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_magf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_magf128-------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumMagTest.h" + +#include "src/math/fmaximum_magf128.h" + +LIST_FMAXIMUM_MAG_TESTS(float128, LIBC_NAMESPACE::fmaximum_magf128) diff --git a/libc/test/src/math/smoke/fmaximum_magf_test.cpp b/libc/test/src/math/smoke/fmaximum_magf_test.cpp new file mode 100644 index 00000000000000..efca320b2b373d --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_magf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_magf----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumMagTest.h" + +#include "src/math/fmaximum_magf.h" + +LIST_FMAXIMUM_MAG_TESTS(float, LIBC_NAMESPACE::fmaximum_magf) diff --git a/libc/test/src/math/smoke/fmaximum_magl_test.cpp b/libc/test/src/math/smoke/fmaximum_magl_test.cpp new file mode 100644 index 00000000000000..16b420b8714b07 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_magl_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_magl----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumMagTest.h" + +#include "src/math/fmaximum_magl.h" + +LIST_FMAXIMUM_MAG_TESTS(long double, LIBC_NAMESPACE::fmaximum_magl) diff --git a/libc/test/src/math/smoke/fmaximum_num_test.cpp b/libc/test/src/math/smoke/fmaximum_num_test.cpp new file mode 100644 index 00000000000000..cb9afdf78b83f5 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_num_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_num-----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMaximumNumTest.h" + +#include "src/math/fmaximum_num.h" + +LIST_FMAXIMUM_NUM_TESTS(double, LIBC_NAMESPACE::fmaximum_num) diff --git a/libc/test/src/math/smoke/fmaximum_numf128_test.cpp b/libc/test/src/math/smoke/fmaximum_numf128_test.cpp new file mode 100644 index 00000000000000..6855ea3b39a9c3 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_numf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_numf128-------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumNumTest.h" + +#include "src/math/fmaximum_numf128.h" + +LIST_FMAXIMUM_NUM_TESTS(float128, LIBC_NAMESPACE::fmaximum_numf128) diff --git a/libc/test/src/math/smoke/fmaximum_numf_test.cpp b/libc/test/src/math/smoke/fmaximum_numf_test.cpp new file mode 100644 index 00000000000000..053d18803e07f9 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_numf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_numf----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumNumTest.h" + +#include "src/math/fmaximum_numf.h" + +LIST_FMAXIMUM_NUM_TESTS(float, LIBC_NAMESPACE::fmaximum_numf) diff --git a/libc/test/src/math/smoke/fmaximum_numl_test.cpp b/libc/test/src/math/smoke/fmaximum_numl_test.cpp new file mode 100644 index 00000000000000..bf9612c4111da1 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_numl_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum_numl----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumNumTest.h" + +#include "src/math/fmaximum_numl.h" + +LIST_FMAXIMUM_NUM_TESTS(long double, LIBC_NAMESPACE::fmaximum_numl) diff --git a/libc/test/src/math/smoke/fmaximum_test.cpp b/libc/test/src/math/smoke/fmaximum_test.cpp new file mode 100644 index 00000000000000..990e0177d8689c --- /dev/null +++ b/libc/test/src/math/smoke/fmaximum_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximum---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMaximumTest.h" + +#include "src/math/fmaximum.h" + +LIST_FMAXIMUM_TESTS(double, LIBC_NAMESPACE::fmaximum) diff --git a/libc/test/src/math/smoke/fmaximumf128_test.cpp b/libc/test/src/math/smoke/fmaximumf128_test.cpp new file mode 100644 index 00000000000000..7e0b97bcdd4de1 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximumf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximumf128-----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumTest.h" + +#include "src/math/fmaximumf128.h" + +LIST_FMAXIMUM_TESTS(float128, LIBC_NAMESPACE::fmaximumf128) diff --git a/libc/test/src/math/smoke/fmaximumf_test.cpp b/libc/test/src/math/smoke/fmaximumf_test.cpp new file mode 100644 index 00000000000000..a92bbd1446e71a --- /dev/null +++ b/libc/test/src/math/smoke/fmaximumf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximumf--------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumTest.h" + +#include "src/math/fmaximumf.h" + +LIST_FMAXIMUM_TESTS(float, LIBC_NAMESPACE::fmaximumf) diff --git a/libc/test/src/math/smoke/fmaximuml_test.cpp b/libc/test/src/math/smoke/fmaximuml_test.cpp new file mode 100644 index 00000000000000..080847b9f4de85 --- /dev/null +++ b/libc/test/src/math/smoke/fmaximuml_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fmaximuml--------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMaximumTest.h" + +#include "src/math/fmaximuml.h" + +LIST_FMAXIMUM_TESTS(long double, LIBC_NAMESPACE::fmaximuml) diff --git a/libc/test/src/math/smoke/fminimum_mag_num_test.cpp b/libc/test/src/math/smoke/fminimum_mag_num_test.cpp new file mode 100644 index 00000000000000..471f2ceb3c2cdc --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_mag_num_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_mag_num-------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMinimumMagNumTest.h" + +#include "src/math/fminimum_mag_num.h" + +LIST_FMINIMUM_MAG_NUM_TESTS(double, LIBC_NAMESPACE::fminimum_mag_num) diff --git a/libc/test/src/math/smoke/fminimum_mag_numf128_test.cpp b/libc/test/src/math/smoke/fminimum_mag_numf128_test.cpp new file mode 100644 index 00000000000000..f1db025f489540 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_mag_numf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_mag_numf128---------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumMagNumTest.h" + +#include "src/math/fminimum_mag_numf128.h" + +LIST_FMINIMUM_MAG_NUM_TESTS(float128, LIBC_NAMESPACE::fminimum_mag_numf128) diff --git a/libc/test/src/math/smoke/fminimum_mag_numf_test.cpp b/libc/test/src/math/smoke/fminimum_mag_numf_test.cpp new file mode 100644 index 00000000000000..773ba806b99ecb --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_mag_numf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_mag_numf------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumMagNumTest.h" + +#include "src/math/fminimum_mag_numf.h" + +LIST_FMINIMUM_MAG_NUM_TESTS(float, LIBC_NAMESPACE::fminimum_mag_numf) diff --git a/libc/test/src/math/smoke/fminimum_mag_numl_test.cpp b/libc/test/src/math/smoke/fminimum_mag_numl_test.cpp new file mode 100644 index 00000000000000..b4152779db7301 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_mag_numl_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_mag_numl------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumMagNumTest.h" + +#include "src/math/fminimum_mag_numl.h" + +LIST_FMINIMUM_MAG_NUM_TESTS(long double, LIBC_NAMESPACE::fminimum_mag_numl) diff --git a/libc/test/src/math/smoke/fminimum_mag_test.cpp b/libc/test/src/math/smoke/fminimum_mag_test.cpp new file mode 100644 index 00000000000000..f4138f3353d11c --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_mag_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_mag-----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMinimumMagTest.h" + +#include "src/math/fminimum_mag.h" + +LIST_FMINIMUM_MAG_TESTS(double, LIBC_NAMESPACE::fminimum_mag) diff --git a/libc/test/src/math/smoke/fminimum_magf128_test.cpp b/libc/test/src/math/smoke/fminimum_magf128_test.cpp new file mode 100644 index 00000000000000..010ee6e73bee09 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_magf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_magf128-------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumMagTest.h" + +#include "src/math/fminimum_magf128.h" + +LIST_FMINIMUM_MAG_TESTS(float128, LIBC_NAMESPACE::fminimum_magf128) diff --git a/libc/test/src/math/smoke/fminimum_magf_test.cpp b/libc/test/src/math/smoke/fminimum_magf_test.cpp new file mode 100644 index 00000000000000..aa27431489309b --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_magf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_magf----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumMagTest.h" + +#include "src/math/fminimum_magf.h" + +LIST_FMINIMUM_MAG_TESTS(float, LIBC_NAMESPACE::fminimum_magf) diff --git a/libc/test/src/math/smoke/fminimum_magl_test.cpp b/libc/test/src/math/smoke/fminimum_magl_test.cpp new file mode 100644 index 00000000000000..c6fbf7df0e70a7 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_magl_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_magl----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumMagTest.h" + +#include "src/math/fminimum_magl.h" + +LIST_FMINIMUM_MAG_TESTS(long double, LIBC_NAMESPACE::fminimum_magl) diff --git a/libc/test/src/math/smoke/fminimum_num_test.cpp b/libc/test/src/math/smoke/fminimum_num_test.cpp new file mode 100644 index 00000000000000..1be7ebb5fe8e9f --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_num_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_num-----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMinimumNumTest.h" + +#include "src/math/fminimum_num.h" + +LIST_FMINIMUM_NUM_TESTS(double, LIBC_NAMESPACE::fminimum_num) diff --git a/libc/test/src/math/smoke/fminimum_numf128_test.cpp b/libc/test/src/math/smoke/fminimum_numf128_test.cpp new file mode 100644 index 00000000000000..d773d8973286e8 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_numf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_numf128-------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumNumTest.h" + +#include "src/math/fminimum_numf128.h" + +LIST_FMINIMUM_NUM_TESTS(float128, LIBC_NAMESPACE::fminimum_numf128) diff --git a/libc/test/src/math/smoke/fminimum_numf_test.cpp b/libc/test/src/math/smoke/fminimum_numf_test.cpp new file mode 100644 index 00000000000000..9b60f39d55a8d0 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_numf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_numf----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumNumTest.h" + +#include "src/math/fminimum_numf.h" + +LIST_FMINIMUM_NUM_TESTS(float, LIBC_NAMESPACE::fminimum_numf) diff --git a/libc/test/src/math/smoke/fminimum_numl_test.cpp b/libc/test/src/math/smoke/fminimum_numl_test.cpp new file mode 100644 index 00000000000000..8a72cd8adc5bf1 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_numl_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum_numl----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumNumTest.h" + +#include "src/math/fminimum_numl.h" + +LIST_FMINIMUM_NUM_TESTS(long double, LIBC_NAMESPACE::fminimum_numl) diff --git a/libc/test/src/math/smoke/fminimum_test.cpp b/libc/test/src/math/smoke/fminimum_test.cpp new file mode 100644 index 00000000000000..7778f1c2311c00 --- /dev/null +++ b/libc/test/src/math/smoke/fminimum_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimum---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===---------------------------------------------------------------------===// + +#include "FMinimumTest.h" + +#include "src/math/fminimum.h" + +LIST_FMINIMUM_TESTS(double, LIBC_NAMESPACE::fminimum) diff --git a/libc/test/src/math/smoke/fminimumf128_test.cpp b/libc/test/src/math/smoke/fminimumf128_test.cpp new file mode 100644 index 00000000000000..163090b8a9ec5c --- /dev/null +++ b/libc/test/src/math/smoke/fminimumf128_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimumf128-----------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumTest.h" + +#include "src/math/fminimumf128.h" + +LIST_FMINIMUM_TESTS(float128, LIBC_NAMESPACE::fminimumf128) diff --git a/libc/test/src/math/smoke/fminimumf_test.cpp b/libc/test/src/math/smoke/fminimumf_test.cpp new file mode 100644 index 00000000000000..2ca0f2f35a7ff3 --- /dev/null +++ b/libc/test/src/math/smoke/fminimumf_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimumf--------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumTest.h" + +#include "src/math/fminimumf.h" + +LIST_FMINIMUM_TESTS(float, LIBC_NAMESPACE::fminimumf) diff --git a/libc/test/src/math/smoke/fminimuml_test.cpp b/libc/test/src/math/smoke/fminimuml_test.cpp new file mode 100644 index 00000000000000..3c067ae23f45dc --- /dev/null +++ b/libc/test/src/math/smoke/fminimuml_test.cpp @@ -0,0 +1,13 @@ +//===-- Unittests for fminimuml--------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "FMinimumTest.h" + +#include "src/math/fminimuml.h" + +LIST_FMINIMUM_TESTS(long double, LIBC_NAMESPACE::fminimuml)