Added hypot3 and header conflict tests

Author: ZERICO2005

src/libc/header_test.c

@@ -0,0 +1,27 @@
+#include <alloca.h>
+#include <assert.h>
+#include <byteswap.h>
+#include <cdefs.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fenv.h>
+#include <float.h>
+#include <inttypes.h>
+#include <iso646.h>
+#include <limits.h>
+#include <math.h>
+#include <setjmp.h>
+#include <stdalign.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdnoreturn.h>
+#include <string.h>
+#include <tgmath.h>
+#include <time.h>
+#include <wchar.h>
+
+/* Tests for conflicts */

src/libc/hypot3f.c

@@ -0,0 +1,43 @@
+#include <math.h>
+#include <stdint.h>
+
+typedef union F32_pun {
+    float flt;
+    uint32_t bin;
+} F32_pun;
+
+float __hypot3f(float arg_x, float arg_y, float arg_z) {
+    F32_pun x, y, z;
+    x.flt = fabsf(arg_x);
+    y.flt = fabsf(arg_y);
+	z.flt = fabsf(arg_z);
+    if (y.bin < z.bin) {
+        float temp = y.flt;
+        y.flt = z.flt;
+        z.flt = temp;
+    }
+    if (x.bin < y.bin) {
+        float temp = x.flt;
+        x.flt = y.flt;
+        y.flt = temp;
+    }
+    // x >= y && x >= z, or x is NaN
+    if (isfinite(x.flt)) {
+        int expon;
+        // scale the arguments to prevent overflow/underflow
+        x.flt = frexpf(x.flt, &expon);
+        y.flt = ldexpf(y.flt, -expon);
+        z.flt = ldexpf(z.flt, -expon);
+        // evaluating in this order ensures consistency when arguments are swapped
+        float ret = sqrtf(x.flt * x.flt + (y.flt * y.flt + z.flt * z.flt));
+        return ldexpf(ret, expon);
+    }
+    if (isinf(y.flt) || isinf(z.flt)) {
+        // return infinity, even if the other argument is NaN
+        return HUGE_VALF;
+    }
+    // x is infinity/NaN
+    return x.flt;
+}
+
+double __hypot3(double, double, double) __attribute__((alias("__hypot3f")));

src/libc/hypot3l.c

@@ -0,0 +1,41 @@
+#include <math.h>
+#include <stdint.h>
+
+typedef union F64_pun {
+    long double flt;
+    uint64_t bin;
+} F64_pun;
+
+long double __hypot3l(long double arg_x, long double arg_y, long double arg_z) {
+    F64_pun x, y, z;
+    x.flt = fabsl(arg_x);
+    y.flt = fabsl(arg_y);
+    z.flt = fabsl(arg_z);
+    if (y.bin < z.bin) {
+        long double temp = y.flt;
+        y.flt = z.flt;
+        z.flt = temp;
+    }
+    if (x.bin < y.bin) {
+        long double temp = x.flt;
+        x.flt = y.flt;
+        y.flt = temp;
+    }
+    // x >= y && x >= z, or x is NaN
+    if (isfinite(x.flt)) {
+        int expon;
+        // scale the arguments to prevent overflow/underflow
+        x.flt = frexpl(x.flt, &expon);
+        y.flt = ldexpl(y.flt, -expon);
+        z.flt = ldexpl(z.flt, -expon);
+        // evaluating in this order ensures consistency when arguments are swapped
+        long double ret = sqrtl(x.flt * x.flt + (y.flt * y.flt + z.flt * z.flt));
+        return ldexpl(ret, expon);
+    }
+    if (isinf(y.flt) || isinf(z.flt)) {
+        // return infinity, even if the other argument is NaN
+        return HUGE_VALL;
+    }
+    // x is infinity/NaN
+    return x.flt;
+}

src/libc/include/math.h

@@ -255,6 +255,10 @@ double      hypot(double, double);
 float       hypotf(float, float);
 long double hypotl(long double, long double);
 
+double      __hypot3(double, double, double);
+float       __hypot3f(float, float, float);
+long double __hypot3l(long double, long double, long double);
+
 int         ilogb(double);
 int         ilogbf(float);
 int         ilogbl(long double);

src/libc/include/tgmath.h

@@ -9,6 +9,7 @@
 
 #include <math.h>
 
+
 #define __tgmath_promote(x) _Generic((x), \
     float: ((float)0.f), \
     default: ((double)0.), \
@@ -301,12 +302,6 @@
     float: fmodf \
 )((x), (y))
 
-#define hypot(x, y) _Generic(__tgmath_promote(x) + __tgmath_promote(y), \
-    long double: hypotl, \
-    default: hypot, \
-    float: hypotf \
-)((x), (y))
-
 #define nextafter(x, y) _Generic(__tgmath_promote(x) + __tgmath_promote(y), \
     long double: nextafterl, \
     default: nextafter, \
@@ -369,6 +364,27 @@
     float: scalbnf \
 )((x), (y))
 
+/* hypot */
+
+#define __tgmath_hypot2(x, y) _Generic(__tgmath_promote(x) + __tgmath_promote(y), \
+    long double: hypotl, \
+    default: hypot, \
+    float: hypotf \
+)((x), (y))
+
+#define __tgmath_hypot3(x, y, z) _Generic(__tgmath_promote(x) + __tgmath_promote(y) + __tgmath_promote(z), \
+    long double: __hypot3l, \
+    default: __hypot3, \
+    float: __hypot3f \
+)((x), (y), (z))
+
+#define __tgmath_hypot2(x,y)2
+#define __tgmath_hypot3(x,y,z)3
+#define __tgmath_hypot_count(_1,_2,_3,count,...)count
+#define __tgmath_JOIN2(X,Y)X##Y
+#define __tgmath_CONCAT(X,Y)__tgmath_JOIN2(X,Y)
+#define hypot(...)__tgmath_CONCAT(__tgmath_hypot,__tgmath_hypot_count(__VA_ARGS__,3,2,))(__VA_ARGS__)
+
 #endif /* __cplusplus */
 
 #endif /* _TGMATH_H */

src/libcxx/header_test.cpp

@@ -0,0 +1,61 @@
+#include <__config>
+#include <bit>
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cfloat>
+#include <cinttypes>
+#include <ciso646>
+#include <climits>
+#include <cmath>
+#if __cplusplus >= 201907L
+#include <concepts>
+#endif // __cplusplus >= 201907L
+#include <csetjmp>
+#include <cstdalign>
+#include <cstdbool>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <ctgmath>
+#include <cxxabi.h>
+#include <exception>
+#include <initializer_list>
+#include <limits>
+#include <new>
+#include <numbers>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <version>
+
+#include <alloca.h>
+#include <assert.h>
+#include <byteswap.h>
+#include <cdefs.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fenv.h>
+#include <float.h>
+#include <inttypes.h>
+#include <iso646.h>
+#include <limits.h>
+#include <math.h>
+#include <setjmp.h>
+#include <stdalign.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdnoreturn.h>
+#include <string.h>
+#include <tgmath.h>
+#include <time.h>
+#include <wchar.h>
+
+// tests for conflicts

src/libcxx/include/cmath

@@ -238,6 +238,12 @@ template<typename _Tp, typename _Up> inline constexpr enable_if_t<is_integral_v<
                                                                   is_integral_v<_Up>, double>
 hypot(_Tp __x, _Up __y) { return hypot(__x, __y); }
 
+inline float hypot(float __x, float __y, float __z) { return __hypot3f(__x, __y, __z); }
+inline long double hypot(long double __x, long double __y, long double __z) { __hypot3l(__x, __y, __z); }
+template<typename _Tp, typename _Up, typename _Vp>
+inline enable_if_t<is_integral_v<_Tp> && is_integral_v<_Up> && is_integral_v<_Vp>, double>
+hypot(_Tp __x, _Up __y, _Vp __z) { return __hypot3(__x, __y, __z); }
+
 using ::ilogb;
 using ::ilogbf;
 using ::ilogbl;

src/libcxx/include/version

@@ -54,7 +54,7 @@
 // # define __cpp_lib_gcd_lcm                              201606L
 // # define __cpp_lib_hardware_interference_size           201703L
 // # define __cpp_lib_has_unique_object_representations    201606L
-// # define __cpp_lib_hypot                                201603L
+# define __cpp_lib_hypot                                201603L
 // # define __cpp_lib_incomplete_container_elements        201505L
 // # define __cpp_lib_invoke                               201411L
 // # define __cpp_lib_is_aggregate                         201703L