This is an archive of the discontinued LLVM Phabricator instance.

Differential D92353

[libc] Fix couple of corner cases in remquo.
ClosedPublic

Authored by sivachandra on Nov 30 2020, 4:08 PM.

Details

Reviewers
lntue
Commits
rG19c3894f9436: [libc] Fix couple of corner cases in remquo.
Summary

These two cases are fixed:

  1. If numerator is not zero and denominator is infinity, then the

numerator is returned as the remainder.

  1. If numerator and denominator are equal in magnitude, then quotient

with the right sign is returned.

The differet tests of remquo, remquof and remquol have been unified
into a single file to avoid duplication.

Diff Detail

Event Timeline

sivachandra created this revision.Nov 30 2020, 4:08 PM
Herald added a project: Restricted Project. · View Herald TranscriptNov 30 2020, 4:08 PM
Herald added subscribers: libc-commits, ecnelises, tschuett, mgorny. · View Herald Transcript
sivachandra requested review of this revision.Nov 30 2020, 4:08 PM
Harbormaster completed remote builds in B80593: Diff 308498.Nov 30 2020, 5:12 PM
lntue accepted this revision.Dec 1 2020, 12:04 PM
This revision is now accepted and ready to land.Dec 1 2020, 12:04 PM
This revision was landed with ongoing or failed builds.Dec 2 2020, 11:49 AM
Closed by commit rG19c3894f9436: [libc] Fix couple of corner cases in remquo. (authored by sivachandra). · Explain Why
This revision was automatically updated to reflect the committed changes.
sivachandra added a commit: rG19c3894f9436: [libc] Fix couple of corner cases in remquo..

Revision Contents

PathSize
libc/
test/
src/
math/
6 lines
144 lines
80 lines
80 lines
86 lines
utils/
FPUtil/
11 lines

Diff 309023

libc/test/src/math/CMakeLists.txt

Show First 20 Lines • Show All 680 Lines • ▼ Show 20 Lines
add_fp_unittest( add_fp_unittest(
remquof_test remquof_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
remquof_test.cpp remquof_test.cpp
HDRS
RemQuoTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.remquof libc.src.math.remquof
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
remquo_test remquo_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
remquo_test.cpp remquo_test.cpp
HDRS
RemQuoTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.remquo libc.src.math.remquo
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
remquol_test remquol_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
remquol_test.cpp remquol_test.cpp
HDRS
RemQuoTest.h
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.remquol libc.src.math.remquol
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_fp_unittest( add_fp_unittest(
hypotf_test hypotf_test
Show All 10 Lines

libc/test/src/math/RemQuoTest.h

  • This file was added.
//===-- Utility class to test different flavors of remquo -------*- 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_REMQUOTEST_H
#define LLVM_LIBC_TEST_SRC_MATH_REMQUOTEST_H
#include "utils/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>
namespace mpfr = __llvm_libc::testing::mpfr;
template <typename T>
class RemQuoTestTemplate : public __llvm_libc::testing::Test {
using FPBits = __llvm_libc::fputil::FPBits<T>;
using UIntType = typename FPBits::UIntType;
const T zero = __llvm_libc::fputil::FPBits<T>::zero();
const T negZero = __llvm_libc::fputil::FPBits<T>::negZero();
const T inf = __llvm_libc::fputil::FPBits<T>::inf();
const T negInf = __llvm_libc::fputil::FPBits<T>::negInf();
const T nan = __llvm_libc::fputil::FPBits<T>::buildNaN(1);
public:
typedef T (*RemQuoFunc)(T, T, int *);
void testSpecialNumbers(RemQuoFunc func) {
int quotient;
T x, y;
y = T(1.0);
x = inf;
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
x = negInf;
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
x = T(1.0);
y = zero;
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
y = negZero;
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
y = nan;
x = T(1.0);
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
y = T(1.0);
x = nan;
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
x = nan;
y = nan;
EXPECT_NE(isnan(func(x, y, &quotient)), 0);
x = zero;
y = T(1.0);
EXPECT_FP_EQ(func(x, y, &quotient), zero);
x = negZero;
y = T(1.0);
EXPECT_FP_EQ(func(x, y, &quotient), negZero);
x = T(1.125);
y = inf;
EXPECT_FP_EQ(func(x, y, &quotient), x);
EXPECT_EQ(quotient, 0);
}
void testEqualNumeratorAndDenominator(RemQuoFunc func) {
T x = T(1.125), y = T(1.125);
int q;
// When the remainder is zero, the standard requires it to
// have the same sign as x.
EXPECT_FP_EQ(func(x, y, &q), zero);
EXPECT_EQ(q, 1);
EXPECT_FP_EQ(func(x, -y, &q), zero);
EXPECT_EQ(q, -1);
EXPECT_FP_EQ(func(-x, y, &q), negZero);
EXPECT_EQ(q, -1);
EXPECT_FP_EQ(func(-x, -y, &q), negZero);
EXPECT_EQ(q, 1);
}
void testSubnormalRange(RemQuoFunc func) {
constexpr UIntType count = 1000001;
constexpr UIntType step =
(FPBits::maxSubnormal - FPBits::minSubnormal) / count;
for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
v += step, w -= step) {
T x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}
void testNormalRange(RemQuoFunc func) {
constexpr UIntType count = 1000001;
constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
v <= FPBits::maxNormal && w >= FPBits::minNormal;
v += step, w -= step) {
T x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<T> result;
mpfr::BinaryInput<T> input{x, y};
result.f = func(x, y, &result.i);
// In normal range on x86 platforms, the long double implicit 1 bit can be
// zero making the numbers NaN. Hence we test for them separately.
if (isnan(x) || isnan(y)) {
ASSERT_NE(isnan(result.f), 0);
continue;
}
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}
};
#define LIST_REMQUO_TESTS(T, func) \
using RemQuoTest = RemQuoTestTemplate<T>; \
TEST_F(RemQuoTest, SpecialNumbers) { testSpecialNumbers(&func); } \
TEST_F(RemQuoTest, EqualNumeratorAndDenominator) { \
testEqualNumeratorAndDenominator(&func); \
} \
TEST_F(RemQuoTest, SubnormalRange) { testSubnormalRange(&func); } \
TEST_F(RemQuoTest, NormalRange) { testNormalRange(&func); }
#endif // LLVM_LIBC_TEST_SRC_MATH_REMQUOTEST_H

libc/test/src/math/remquo_test.cpp

//===-- Unittests for remquo ----------------------------------------------===// //===-- Unittests for remquo ----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquo.h" #include "RemQuoTest.h"
#include "utils/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<double>;
using UIntType = FPBits::UIntType;
namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(double)
TEST(RemquoTest, SpecialNumbers) {
int exponent;
double x, y;
y = 1.0;
x = inf;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
x = negInf;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
x = 1.0;
y = zero;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
y = negZero;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
y = nan; #include "src/math/remquo.h"
x = 1.0;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
y = 1.0;
x = nan;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
x = nan;
y = nan;
EXPECT_NE(isnan(__llvm_libc::remquo(x, y, &exponent)), 0);
x = zero;
y = 1.0;
EXPECT_FP_EQ(__llvm_libc::remquo(x, y, &exponent), zero);
x = negZero;
y = 1.0;
EXPECT_FP_EQ(__llvm_libc::remquo(x, y, &exponent), negZero);
}
TEST(RemquoTest, SubnormalRange) {
constexpr UIntType count = 1000001;
constexpr UIntType step =
(FPBits::maxSubnormal - FPBits::minSubnormal) / count;
for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
v += step, w -= step) {
double x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<double> result;
mpfr::BinaryInput<double> input{x, y};
result.f = __llvm_libc::remquo(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}
TEST(RemquoTest, NormalRange) { LIST_REMQUO_TESTS(double, __llvm_libc::remquo)
constexpr UIntType count = 1000001;
constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
v <= FPBits::maxNormal && w >= FPBits::minNormal; v += step, w -= step) {
double x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<double> result;
mpfr::BinaryInput<double> input{x, y};
result.f = __llvm_libc::remquo(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}

libc/test/src/math/remquof_test.cpp

//===-- Unittests for remquof ---------------------------------------------===// //===-- Unittests for remquof ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquof.h" #include "RemQuoTest.h"
#include "utils/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<float>;
using UIntType = FPBits::UIntType;
namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(float)
TEST(RemquofTest, SpecialNumbers) {
int exponent;
float x, y;
y = 1.0f;
x = inf;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
x = negInf;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
x = 1.0f;
y = zero;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
y = negZero;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
y = nan; #include "src/math/remquof.h"
x = 1.0f;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
y = 1.0f;
x = nan;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
x = nan;
y = nan;
EXPECT_NE(isnan(__llvm_libc::remquof(x, y, &exponent)), 0);
x = zero;
y = 1.0f;
EXPECT_FP_EQ(__llvm_libc::remquof(x, y, &exponent), zero);
x = negZero;
y = 1.0f;
EXPECT_FP_EQ(__llvm_libc::remquof(x, y, &exponent), negZero);
}
TEST(RemquofTest, SubnormalRange) {
constexpr UIntType count = 1000001;
constexpr UIntType step =
(FPBits::maxSubnormal - FPBits::minSubnormal) / count;
for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
v += step, w -= step) {
float x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<float> result;
mpfr::BinaryInput<float> input{x, y};
result.f = __llvm_libc::remquof(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}
TEST(RemquofTest, NormalRange) { LIST_REMQUO_TESTS(float, __llvm_libc::remquof)
constexpr UIntType count = 1000001;
constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
v <= FPBits::maxNormal && w >= FPBits::minNormal; v += step, w -= step) {
float x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<float> result;
mpfr::BinaryInput<float> input{x, y};
result.f = __llvm_libc::remquof(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}

libc/test/src/math/remquol_test.cpp

//===-- Unittests for remquol ---------------------------------------------===// //===-- Unittests for remquol ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "src/math/remquol.h" #include "RemQuoTest.h"
#include "utils/FPUtil/BasicOperations.h"
#include "utils/FPUtil/FPBits.h"
#include "utils/FPUtil/TestHelpers.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
#include <math.h>
using FPBits = __llvm_libc::fputil::FPBits<long double>;
using UIntType = FPBits::UIntType;
namespace mpfr = __llvm_libc::testing::mpfr;
DECLARE_SPECIAL_CONSTANTS(long double)
TEST(RemquolTest, SpecialNumbers) {
int exponent;
long double x, y;
y = 1.0l;
x = inf;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
x = negInf;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
x = 1.0l;
y = zero;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
y = negZero;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
y = nan; #include "src/math/remquol.h"
x = 1.0l;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
y = 1.0l;
x = nan;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
x = nan;
y = nan;
EXPECT_NE(isnan(__llvm_libc::remquol(x, y, &exponent)), 0);
x = zero;
y = 1.0l;
EXPECT_FP_EQ(__llvm_libc::remquol(x, y, &exponent), zero);
x = negZero;
y = 1.0l;
EXPECT_FP_EQ(__llvm_libc::remquol(x, y, &exponent), negZero);
}
TEST(RemquolTest, SubnormalRange) {
constexpr UIntType count = 1000001;
constexpr UIntType step =
(FPBits::maxSubnormal - FPBits::minSubnormal) / count;
for (UIntType v = FPBits::minSubnormal, w = FPBits::maxSubnormal;
v <= FPBits::maxSubnormal && w >= FPBits::minSubnormal;
v += step, w -= step) {
long double x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<long double> result;
mpfr::BinaryInput<long double> input{x, y};
result.f = __llvm_libc::remquol(x, y, &result.i);
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}
TEST(RemquolTest, NormalRange) { LIST_REMQUO_TESTS(long double, __llvm_libc::remquol)
constexpr UIntType count = 1000001;
constexpr UIntType step = (FPBits::maxNormal - FPBits::minNormal) / count;
for (UIntType v = FPBits::minNormal, w = FPBits::maxNormal;
v <= FPBits::maxNormal && w >= FPBits::minNormal; v += step, w -= step) {
long double x = FPBits(v), y = FPBits(w);
mpfr::BinaryOutput<long double> result;
result.f = __llvm_libc::remquol(x, y, &result.i);
// In normal range on x86 platforms, the implicit 1 bit can be zero making
// the numbers NaN. Hence we test for them separately.
if (isnan(x) || isnan(y)) {
ASSERT_NE(isnan(result.f), 0);
} else {
mpfr::BinaryInput<long double> input{x, y};
ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
}
}
}

libc/utils/FPUtil/DivisionAndRemainderOperations.h

Show All 27 Linesstatic inline T remquo(T x, T y, int &q) {
FPBits<T> xbits(x), ybits(y); FPBits<T> xbits(x), ybits(y);
if (xbits.isNaN()) if (xbits.isNaN())
return x; return x;
if (ybits.isNaN()) if (ybits.isNaN())
return y; return y;
if (xbits.isInf() || ybits.isZero()) if (xbits.isInf() || ybits.isZero())
return FPBits<T>::buildNaN(1); return FPBits<T>::buildNaN(1);
if (xbits.isZero() || ybits.isInf()) { if (xbits.isZero()) {
q = 0; q = 0;
return __llvm_libc::fputil::copysign(T(0.0), x); return __llvm_libc::fputil::copysign(T(0.0), x);
} }
if (ybits.isInf()) {
q = 0;
return x;
}
bool resultSign = (xbits.sign == ybits.sign ? false : true); bool resultSign = (xbits.sign == ybits.sign ? false : true);
// Once we know the sign of the result, we can just operate on the absolute // Once we know the sign of the result, we can just operate on the absolute
// values. The correct sign can be applied to the result after the result // values. The correct sign can be applied to the result after the result
// is evaluated. // is evaluated.
xbits.sign = ybits.sign = 0; xbits.sign = ybits.sign = 0;
NormalFloat<T> normalx(xbits), normaly(ybits); NormalFloat<T> normalx(xbits), normaly(ybits);
Show All 11 Lines while (exp >= 0) {
if (static_cast<int>(shiftCount) > exp) if (static_cast<int>(shiftCount) > exp)
break; break;
exp -= shiftCount; exp -= shiftCount;
if (0 <= exp && exp < quotientLSBBits) if (0 <= exp && exp < quotientLSBBits)
q |= (1 << exp); q |= (1 << exp);
mx = n - my; mx = n - my;
if (mx == 0) if (mx == 0) {
q = resultSign ? -q : q;
return __llvm_libc::fputil::copysign(T(0.0), x); return __llvm_libc::fputil::copysign(T(0.0), x);
} }
}
NormalFloat<T> remainder(exp + normaly.exponent, mx, 0); NormalFloat<T> remainder(exp + normaly.exponent, mx, 0);
// Since NormalFloat to native type conversion is a truncation operation // Since NormalFloat to native type conversion is a truncation operation
// currently, the remainder value in the native type is correct as is. // currently, the remainder value in the native type is correct as is.
// However, if NormalFloat to native type conversion is updated in future, // However, if NormalFloat to native type conversion is updated in future,
// then the conversion to native remainder value should be updated // then the conversion to native remainder value should be updated
// appropriately and some directed tests added. // appropriately and some directed tests added.
Show All 33 Lines