derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
641 lines
30 KiB
C++
641 lines
30 KiB
C++
//===-- Unittests for shared math functions in constexpr context ----------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define LIBC_ENABLE_CONSTEXPR 1
|
|
|
|
#include "shared/math.h"
|
|
#include "test/UnitTest/Test.h"
|
|
|
|
#ifdef LIBC_USE_CONSTEXPR
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Double Tests
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static_assert(0 == [] {
|
|
double cx = 0.0;
|
|
double x = 0.0;
|
|
return LIBC_NAMESPACE::shared::canonicalize(&cx, &x);
|
|
}());
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::ceil(0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::copysign(0.0, 0.0));
|
|
static_assert(1.0 == LIBC_NAMESPACE::shared::fabs(-1.0));
|
|
static_assert(1.0 == LIBC_NAMESPACE::shared::fdim(1.0, 0.0));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fdiv(0.0, 1.0));
|
|
static_assert(1.0 == LIBC_NAMESPACE::shared::floor(1.2));
|
|
static_assert(2.0 == LIBC_NAMESPACE::shared::fmaximum_mag_num(1.0, 2.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::log(1.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fmaximum(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fminimum(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fmin(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fmax(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fmaximum_num(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fminimum_num(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fromfp(0.0, 0, 32));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fromfpx(0.0, 0, 32));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::ufromfp(0.0, 0, 32));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::ufromfpx(0.0, 0, 32));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fmaximum_mag(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fminimum_mag(0.0, 0.0));
|
|
static_assert(-1.0 == [] {
|
|
double getpayload_x = 0.0;
|
|
return LIBC_NAMESPACE::shared::getpayload(&getpayload_x);
|
|
}());
|
|
|
|
constexpr double TOTALORDER_X = 0.0;
|
|
constexpr double TOTALORDER_Y = 0.0;
|
|
static_assert(1 ==
|
|
LIBC_NAMESPACE::shared::totalorder(&TOTALORDER_X, &TOTALORDER_Y));
|
|
constexpr double TOTALORDERMAG_X = 0.0;
|
|
constexpr double TOTALORDERMAG_Y = 0.0;
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalordermag(&TOTALORDERMAG_X,
|
|
&TOTALORDERMAG_Y));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fmod(4.0, 2.0));
|
|
static_assert(0.0 == [] {
|
|
double iptr = 0;
|
|
return LIBC_NAMESPACE::shared::modf(0, &iptr);
|
|
}());
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::fminimum_mag_num(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::remainder(1.0, 1.0));
|
|
static_assert(0.0 == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::remquo(1.0, 1.0, &exp);
|
|
}());
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::ldexp(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::scalbln(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::scalbn(0.0, 0.0));
|
|
static_assert(0 == [] {
|
|
double setpayload_x = 0.0;
|
|
return LIBC_NAMESPACE::shared::setpayload(&setpayload_x, 0.0);
|
|
}());
|
|
static_assert(0.0 == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::frexp(0.0, &exp);
|
|
}());
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llrint(0.0));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llround(0.0));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lrint(0.0));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lround(0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::nearbyint(0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::nextafter(0.0, 0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::rint(0.0));
|
|
// TODO: iscanonical clashes with a macro defined in <math.h>
|
|
// static_assert(1 == LIBC_NAMESPACE::shared::iscanonical(0.0));
|
|
// TODO: issignaling clashes with a macro defined in <math.h>
|
|
// static_assert(0.0 == LIBC_NAMESPACE::shared::issignaling(0.0));
|
|
static_assert(1 == [] {
|
|
const char arg{};
|
|
return LIBC_NAMESPACE::fputil::FPBits<double>(
|
|
LIBC_NAMESPACE::shared::nan(&arg))
|
|
.is_nan();
|
|
}());
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::round(0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::roundeven(0.0));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::trunc(0.0));
|
|
// TODO: isnan clashes with a macro defined in <math.h>
|
|
// static_assert(0 == LIBC_NAMESPACE::shared::isnan(0.0));
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Float Tests
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static_assert(0 == [] {
|
|
float cx = 0.0f;
|
|
float x = 0.0f;
|
|
return LIBC_NAMESPACE::shared::canonicalizef(&cx, &x);
|
|
}());
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::ceilf(0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::copysignf(0.0f, 0.0f));
|
|
static_assert(1.0f == LIBC_NAMESPACE::shared::fabsf(-1.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fadd(0.0, 0.0));
|
|
static_assert(1.0f == LIBC_NAMESPACE::shared::fdimf(1.0f, 0.0f));
|
|
static_assert(2.0f == LIBC_NAMESPACE::shared::fmaximum_mag_numf(1.0f, 2.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::floorf(0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmaximumf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fminimumf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fminf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmaxf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmaximum_numf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fminimum_numf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fromfp(0.0f, 0, 32));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fromfpx(0.0f, 0, 32));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::ufromfpf(0.0f, 0, 32));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::ufromfpxf(0.0f, 0, 32));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmaximum_magf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fminimum_magf(0.0f, 0.0f));
|
|
static_assert(-1.0f == [] {
|
|
float getpayload_x = 0.0f;
|
|
return LIBC_NAMESPACE::shared::getpayloadf(&getpayload_x);
|
|
}());
|
|
|
|
constexpr float TOTALORDERF_X = 0.0f;
|
|
constexpr float TOTALORDERF_Y = 0.0f;
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalorderf(&TOTALORDERF_X,
|
|
&TOTALORDERF_Y));
|
|
constexpr float TOTALORDERMAGF_X = 0.0f;
|
|
constexpr float TOTALORDERMAGF_Y = 0.0f;
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalordermagf(&TOTALORDERMAGF_X,
|
|
&TOTALORDERMAGF_Y));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmodf(4.0f, 2.0f));
|
|
static_assert(0.0f == [] {
|
|
float iptr = 0.0f;
|
|
return LIBC_NAMESPACE::shared::modff(0.0f, &iptr);
|
|
}());
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fminimum_mag_numf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::remainderf(1.0f, 1.0f));
|
|
static_assert(0.0f == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::remquof(1.0f, 1.0f, &exp);
|
|
}());
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::scalblnf(0.0f, 0.0));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::scalbnf(0.0f, 0.0));
|
|
static_assert(0 == [] {
|
|
float setpayload_x = 0.0f;
|
|
return LIBC_NAMESPACE::shared::setpayloadf(&setpayload_x, 0.0f);
|
|
}());
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmul(0.0, 0.0));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fsub(0.0, 0.0));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llrintf(0.0f));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llroundf(0.0f));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lrintf(0.0f));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lroundf(0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::nearbyintf(0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::nextafterf(0.0f, 0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::rintf(0.0f));
|
|
static_assert(1 == LIBC_NAMESPACE::shared::iscanonicalf(0.0f));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::issignalingf(0.0f));
|
|
static_assert(1 == [] {
|
|
const char arg{};
|
|
return LIBC_NAMESPACE::fputil::FPBits<float>(
|
|
LIBC_NAMESPACE::shared::nanf(&arg))
|
|
.is_nan();
|
|
}());
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::roundf(0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::roundevenf(0.0f));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::truncf(0.0f));
|
|
static_assert(0 == LIBC_NAMESPACE::shared::isnanf(0.0f));
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Float16 Tests
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifdef LIBC_TYPES_HAS_FLOAT16
|
|
|
|
static_assert(0 == [] {
|
|
float16 cx = 0.0f16;
|
|
float16 x = 0.0f16;
|
|
return LIBC_NAMESPACE::shared::canonicalizef16(&cx, &x);
|
|
}());
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::ceilf16(0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::copysignf16(0.0f16, 0.0f16));
|
|
static_assert(3.0f16 == LIBC_NAMESPACE::shared::f16add(1.0, 2.0));
|
|
static_assert(3.0f16 == LIBC_NAMESPACE::shared::f16addf(1.0f, 2.0f));
|
|
|
|
// TODO: make available after long double problem is fixed
|
|
#if 0
|
|
static_assert(3.0f16 == LIBC_NAMESPACE::shared::f16addl(1.0L, 2.0L));
|
|
#endif
|
|
#ifdef LIBC_TYPES_HAS_FLOAT128
|
|
static_assert(3.0f16 ==
|
|
LIBC_NAMESPACE::shared::f16addf128(float128(1.0), float128(2.0)));
|
|
#endif
|
|
static_assert(1.0f16 == LIBC_NAMESPACE::shared::fabsf16(-1.0f16));
|
|
static_assert(1.0f16 == LIBC_NAMESPACE::shared::fdimf16(1.0f16, 0.0f16));
|
|
static_assert(3.0f16 == LIBC_NAMESPACE::shared::floorf16(3.7f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fmaximumf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fminimumf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fminf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fmaxf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 ==
|
|
LIBC_NAMESPACE::shared::fmaximum_numf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 ==
|
|
LIBC_NAMESPACE::shared::fminimum_numf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fromfpf16(0.0f16, 0, 32));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fromfpxf16(0.0f16, 0, 32));
|
|
static_assert(-1.0f16 == [] {
|
|
float16 getpayload_x = 0.0f16;
|
|
return LIBC_NAMESPACE::shared::getpayloadf16(&getpayload_x);
|
|
}());
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::ufromfpf16(0.0f16, 0, 32));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::ufromfpxf16(0.0f16, 0, 32));
|
|
static_assert(0.0f16 ==
|
|
LIBC_NAMESPACE::shared::fmaximum_magf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 ==
|
|
LIBC_NAMESPACE::shared::fminimum_magf16(0.0f16, 0.0f16));
|
|
|
|
constexpr float16 TOTALORDERF16_X = 0.0f16;
|
|
constexpr float16 TOTALORDERF16_Y = 0.0f16;
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalorderf16(&TOTALORDERF16_X,
|
|
&TOTALORDERF16_Y));
|
|
|
|
constexpr float16 TOTALORDERMAGF16_X = 0.0f16;
|
|
constexpr float16 TOTALORDERMAGF16_Y = 0.0f16;
|
|
static_assert(1 ==
|
|
LIBC_NAMESPACE::shared::totalordermagf16(&TOTALORDERMAGF16_X,
|
|
&TOTALORDERMAGF16_Y));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::fmodf16(4.0f16, 2.0f16));
|
|
static_assert(0.0f16 == [] {
|
|
float16 iptr{};
|
|
return LIBC_NAMESPACE::shared::modff16(0.0f16, &iptr);
|
|
}());
|
|
static_assert(0.0f16 ==
|
|
LIBC_NAMESPACE::shared::fmaximum_mag_numf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 ==
|
|
LIBC_NAMESPACE::shared::fminimum_mag_numf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::remainderf16(1.0f16, 1.0f16));
|
|
static_assert(0.0f16 == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::remquof16(1.0f16, 1.0f16, &exp);
|
|
}());
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::scalblnf16(0.0f16, 0.0));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::scalbnf16(0.0f16, 0.0));
|
|
static_assert(0 == [] {
|
|
float16 setpayload_x = 0.0f16;
|
|
return LIBC_NAMESPACE::shared::setpayloadf16(&setpayload_x, 0.0f16);
|
|
}());
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llrintf16(0.0f16));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llroundf16(0.0f16));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lrintf16(0.0f16));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lroundf16(0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::nearbyintf16(0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::nextafterf16(0.0f16, 0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::rintf16(0.0f16));
|
|
static_assert(1 == LIBC_NAMESPACE::shared::iscanonicalf16(0.0f16));
|
|
static_assert(0 == LIBC_NAMESPACE::shared::isnanf16(0.0f16));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::issignalingf16(0.0f16));
|
|
static_assert(1 == [] {
|
|
const char arg{};
|
|
return LIBC_NAMESPACE::fputil::FPBits<float16>(
|
|
LIBC_NAMESPACE::shared::nanf16(&arg))
|
|
.is_nan();
|
|
}());
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::roundf16(0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::roundevenf16(0.0f16));
|
|
static_assert(0.0f16 == LIBC_NAMESPACE::shared::truncf16(0.0f16));
|
|
#endif // LIBC_TYPES_HAS_FLOAT16
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Long Double Tests
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// TODO(issue#185232): Mark as constexpr once the refactor is done.
|
|
#if 0 // Temporarily disable long double tests
|
|
|
|
static_assert(0 == [] {
|
|
long double cx = 0.0L;
|
|
long double x = 0.0L;
|
|
return LIBC_NAMESPACE::shared::canonicalizel(&cx, &x);
|
|
}());
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::ceill(0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::copysignl(0.0L, 0.0L));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::ddivl(0.0L, 1.0L));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::dmull(0.0L, 1.0L));
|
|
static_assert(1.0L == LIBC_NAMESPACE::shared::fabsl(-1.0L));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::faddl(0.0L, 0.0L));
|
|
static_assert(1.0L == LIBC_NAMESPACE::shared::fdiml(1.0L, 0.0L));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fdivl(0.0L, 1.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::floorl(0.0L));
|
|
static_assert(bfloat16(0.0) == LIBC_NAMESPACE::shared::bf16subl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::sqrtl(0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fmaximuml(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fminimuml(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fminl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fmaxl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fmaximum_numl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fminimum_numl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fromfpl(0.0L, 0, 32));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fromfpxl(0.0L, 0, 32));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::ufromfpl(0.0L, 0, 32));
|
|
static_assert(-1.0L == [] {
|
|
long double getpayload_x = 0.0L;
|
|
return LIBC_NAMESPACE::shared::getpayloadl(&getpayload_x);
|
|
}());
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::ufromfpxl(0.0L, 0, 32));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fmaximum_magl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fminimum_magl(0.0L, 0.0L));
|
|
|
|
constexpr long double TOTALORDERL_X = 0.0L;
|
|
constexpr long double TOTALORDERL_Y = 0.0L;
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalorderl(&TOTALORDERL_X,
|
|
&TOTALORDERL_Y));
|
|
constexpr long double TOTALORDERMAGL_X = 0.0L;
|
|
constexpr long double TOTALORDERMAGL_Y = 0.0L;
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalordermagl(&TOTALORDERMAGL_X,
|
|
&TOTALORDERMAGL_Y));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fmodl(4.0L, 2.0L));
|
|
|
|
static_assert(0.0L == [] {
|
|
long double iptr{};
|
|
return LIBC_NAMESPACE::shared::modfl(0.0L, &iptr);
|
|
}());
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fmaximum_mag_numl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::fminimum_mag_numl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::remainderl(1.0L, 1.0L));
|
|
static_assert(0.0L == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::remquol(1.0L, 1.0L, &exp);
|
|
}());
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::ldexpl(0.0L, 0.0));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::scalblnl(0.0L, 0.0));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::scalbnl(0.0L, 0.0));
|
|
static_assert(0 == [] {
|
|
long double setpayload_x = 0.0L;
|
|
return LIBC_NAMESPACE::shared::setpayloadl(&setpayload_x, 0.0L);
|
|
}());
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fmull(0.0L, 0.0L));
|
|
static_assert(0.0f == LIBC_NAMESPACE::shared::fsubl(0.0L, 0.0L));
|
|
static_assert(0.0L == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::frexpl(0.0L, &exp);
|
|
}());
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llrintl(0.0L));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llroundl(0.0L));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lrintl(0.0L));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lroundl(0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::nearbyintl(0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::nextafterl(0.0L, 0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::rintl(0.0L));
|
|
static_assert(1 == LIBC_NAMESPACE::shared::iscanonicall(0.0L));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::issignalingl(0.0L));
|
|
static_assert(1 == [] {
|
|
const char arg{};
|
|
return LIBC_NAMESPACE::fputil::FPBits<long double>(LIBC_NAMESPACE::shared::nanl(&arg)).is_nan();
|
|
}());
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::roundl(0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::roundevenl(0.0L));
|
|
static_assert(0.0L == LIBC_NAMESPACE::shared::truncl(0.0L));
|
|
static_assert(0 == LIBC_NAMESPACE::shared::isnanl(0.0L));
|
|
|
|
#endif
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Float128 Tests
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifdef LIBC_TYPES_HAS_FLOAT128
|
|
|
|
static_assert(0 == [] {
|
|
float128 cx = float128(0.0);
|
|
float128 x = float128(0.0);
|
|
return LIBC_NAMESPACE::shared::canonicalizef128(&cx, &x);
|
|
}());
|
|
static_assert(float128(0.0) == LIBC_NAMESPACE::shared::ceilf128(float128(0.0)));
|
|
static_assert(float128(1.0) ==
|
|
LIBC_NAMESPACE::shared::fabsf128(float128(-1.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::copysignf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(0.0 ==
|
|
LIBC_NAMESPACE::shared::ddivf128(float128(0.0), float128(1.0)));
|
|
static_assert(0.0 ==
|
|
LIBC_NAMESPACE::shared::dmulf128(float128(0.0), float128(1.0)));
|
|
static_assert(0.0f ==
|
|
LIBC_NAMESPACE::shared::faddf128(float128(0.0), float128(0.0)));
|
|
static_assert(float128(1.0) ==
|
|
LIBC_NAMESPACE::shared::fdimf128(float128(1.0), float128(0.0)));
|
|
static_assert(0.0f ==
|
|
LIBC_NAMESPACE::shared::fdivf128(float128(0.0), float128(1.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::floorf128(float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximumf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimumf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminf128(float128(0.0), float128(0.0)));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::dsqrtf128(float128(0.0)));
|
|
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaxf128(float128(0.0), float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximum_numf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimum_numf128(float128(0.0),
|
|
float128(0.0)));
|
|
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fromfpf128(float128(0.0), 0, 32));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fromfpxf128(float128(0.0), 0, 32));
|
|
static_assert(float128(-1.0) == [] {
|
|
float128 getpayload_x = float128(0.0);
|
|
return LIBC_NAMESPACE::shared::getpayloadf128(&getpayload_x);
|
|
}());
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::ufromfpf128(float128(0.0), 0, 32));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::ufromfpxf128(float128(0.0), 0, 32));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximum_magf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimum_magf128(float128(0.0),
|
|
float128(0.0)));
|
|
constexpr float128 TOTALORDERF128_X = float128(0.0);
|
|
constexpr float128 TOTALORDERF128_Y = float128(0.0);
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalorderf128(&TOTALORDERF128_X,
|
|
&TOTALORDERF128_Y));
|
|
constexpr float128 TOTALORDERMAGF128_X = float128(0.0);
|
|
constexpr float128 TOTALORDERMAGF128_Y = float128(0.0);
|
|
static_assert(1 ==
|
|
LIBC_NAMESPACE::shared::totalordermagf128(&TOTALORDERMAGF128_X,
|
|
&TOTALORDERMAGF128_Y));
|
|
static_assert(0 ==
|
|
LIBC_NAMESPACE::shared::fmodf128(float128(4.0), float128(2.0)));
|
|
static_assert(float128(0.0) == [] {
|
|
float128 iptr{};
|
|
return LIBC_NAMESPACE::shared::modff128(float128(0.0), &iptr);
|
|
}());
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximum_mag_numf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimum_mag_numf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::remainderf128(float128(1.0),
|
|
float128(1.0)));
|
|
static_assert(float128(0.0) == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::remquof128(float128(1.0), float128(1.0), &exp);
|
|
}());
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::scalblnf128(float128(0.0), 0.0));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::scalbnf128(float128(0.0), 0.0));
|
|
static_assert(0 == [] {
|
|
float128 setpayload_x = float128(0.0);
|
|
return LIBC_NAMESPACE::shared::setpayloadf128(&setpayload_x, float128(0.0));
|
|
}());
|
|
static_assert(0.0f ==
|
|
LIBC_NAMESPACE::shared::fmulf128(float128(0.0), float128(0.0)));
|
|
static_assert(0.0f ==
|
|
LIBC_NAMESPACE::shared::fsubf128(float128(0.0), float128(0.0)));
|
|
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llrintf128(float128(0.0)));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llroundf128(float128(0.0)));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lrintf128(float128(0.0)));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lroundf128(float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::nearbyintf128(float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::nextafterf128(float128(0.0),
|
|
float128(0.0)));
|
|
static_assert(float128(0.0) == LIBC_NAMESPACE::shared::rintf128(float128(0.0)));
|
|
static_assert(1 == LIBC_NAMESPACE::shared::iscanonicalf128(float128(0.0)));
|
|
static_assert(0.0 == LIBC_NAMESPACE::shared::issignalingf128(float128(0.0)));
|
|
static_assert(1 == [] {
|
|
const char arg{};
|
|
return LIBC_NAMESPACE::fputil::FPBits<float128>(
|
|
LIBC_NAMESPACE::shared::nanf128(&arg))
|
|
.is_nan();
|
|
}());
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::roundf128(float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::roundevenf128(float128(0.0)));
|
|
static_assert(float128(0.0) ==
|
|
LIBC_NAMESPACE::shared::truncf128(float128(0.0)));
|
|
|
|
#endif // LIBC_TYPES_HAS_FLOAT128
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// BFloat16 Tests
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static_assert(0 == [] {
|
|
bfloat16 cx = bfloat16(0.0);
|
|
bfloat16 x = bfloat16(0.0);
|
|
return LIBC_NAMESPACE::shared::canonicalizebf16(&cx, &x);
|
|
}());
|
|
static_assert(bfloat16(0.0) == LIBC_NAMESPACE::shared::asinbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) == LIBC_NAMESPACE::shared::ceilbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(1.0) ==
|
|
LIBC_NAMESPACE::shared::fabsbf16(bfloat16(-1.0)));
|
|
static_assert(bfloat16(2.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximum_mag_numbf16(bfloat16(1.0),
|
|
bfloat16(2.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::copysignbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(1.0) ==
|
|
LIBC_NAMESPACE::shared::fdimbf16(bfloat16(1.0), bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::floorbf16(bfloat16(0.0f)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::logbbf16(bfloat16(1.0f)));
|
|
static_assert(0 == LIBC_NAMESPACE::shared::ilogbbf16(bfloat16(1.0)));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::llogbbf16(bfloat16(1.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximumbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimumbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminbf16(bfloat16(0.0), bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaxbf16(bfloat16(0.0), bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximum_numbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimum_numbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fromfpbf16(bfloat16(0.0), 0, 32));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fromfpxbf16(bfloat16(0.0), 0, 32));
|
|
|
|
static_assert(bfloat16(-1.0) == [] {
|
|
bfloat16 getpayload_x = bfloat16(0.0);
|
|
return LIBC_NAMESPACE::shared::getpayloadbf16(&getpayload_x);
|
|
}());
|
|
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::ufromfpbf16(bfloat16(0.0), 0, 32));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::ufromfpxbf16(bfloat16(0.0), 0, 32));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fmaximum_magbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimum_magbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
|
|
constexpr bfloat16 TOTALORDERBF16_X = bfloat16(0.0);
|
|
constexpr bfloat16 TOTALORDERBF16_Y = bfloat16(0.0);
|
|
static_assert(1 == LIBC_NAMESPACE::shared::totalorderbf16(&TOTALORDERBF16_X,
|
|
&TOTALORDERBF16_Y));
|
|
constexpr bfloat16 TOTALORDERMAGBF16_X = bfloat16(0.0);
|
|
constexpr bfloat16 TOTALORDERMAGBF16_Y = bfloat16(0.0);
|
|
static_assert(1 ==
|
|
LIBC_NAMESPACE::shared::totalordermagbf16(&TOTALORDERMAGBF16_X,
|
|
&TOTALORDERMAGBF16_Y));
|
|
static_assert(0 ==
|
|
LIBC_NAMESPACE::shared::fmodbf16(bfloat16(4.0), bfloat16(2.0)));
|
|
static_assert(bfloat16(0.0) == [] {
|
|
bfloat16 iptr{};
|
|
return LIBC_NAMESPACE::shared::modfbf16(bfloat16(0.0), &iptr);
|
|
}());
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::fminimum_mag_numbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::remainderbf16(bfloat16(1.0),
|
|
bfloat16(1.0)));
|
|
static_assert(bfloat16(0.0) == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::remquobf16(bfloat16(1.0), bfloat16(1.0), &exp);
|
|
}());
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::ldexpbf16(bfloat16(0.0), 0.0));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::scalblnbf16(bfloat16(0.0), 0.0));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::scalbnbf16(bfloat16(0.0), 0.0));
|
|
static_assert(0 == [] {
|
|
bfloat16 setpayload_x = bfloat16(0.0);
|
|
return LIBC_NAMESPACE::shared::setpayloadbf16(&setpayload_x, bfloat16(0.0));
|
|
}());
|
|
static_assert(bfloat16(0.0) == [] {
|
|
int exp{};
|
|
return LIBC_NAMESPACE::shared::frexpbf16(bfloat16(0.0), &exp);
|
|
}());
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llroundbf16(bfloat16(0.0)));
|
|
static_assert(0LL == LIBC_NAMESPACE::shared::llrintbf16(bfloat16(0.0)));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lrintbf16(bfloat16(0.0)));
|
|
static_assert(0L == LIBC_NAMESPACE::shared::lroundbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::nearbyintbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::nextafterbf16(bfloat16(0.0),
|
|
bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) == LIBC_NAMESPACE::shared::rintbf16(bfloat16(0.0)));
|
|
static_assert(1 == LIBC_NAMESPACE::shared::iscanonicalbf16(bfloat16(0.0)));
|
|
static_assert(0 == LIBC_NAMESPACE::shared::issignalingbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(1) == [] {
|
|
const char arg{};
|
|
return LIBC_NAMESPACE::fputil::FPBits<bfloat16>(
|
|
LIBC_NAMESPACE::shared::nanbf16(&arg))
|
|
.is_nan();
|
|
}());
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::roundbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::roundevenbf16(bfloat16(0.0)));
|
|
static_assert(bfloat16(0.0) ==
|
|
LIBC_NAMESPACE::shared::truncbf16(bfloat16(0.0)));
|
|
|
|
#endif // LIBC_USE_CONTEXPR
|
|
|
|
TEST(LlvmLibcSharedMathTest, ConstantEvaluation) {}
|