This is an archive of the discontinued LLVM Phabricator instance.

Differential D80779

[libc] Add implementations of round and roundf.
ClosedPublic

Authored by sivachandra on May 28 2020, 11:25 PM.

Details

Reviewers
abrachet
phosek
asteinhauser
Commits
rG4be1c116ad86: [libc] Add implementations of round and roundf.
Summary

Depends on D80612.

Diff Detail

Event Timeline

sivachandra created this revision.May 28 2020, 11:25 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 28 2020, 11:25 PM
Herald added subscribers: libc-commits, ecnelises, tschuett, mgorny. · View Herald Transcript
sivachandra added a comment.May 28 2020, 11:32 PM

Depends on D80612.

sivachandra edited the summary of this revision. (Show Details)May 28 2020, 11:32 PM
sivachandra added a parent revision: D80612: [libc] Add implementations of ceil[f], floor[f] and trunc[f] from math.h..
Harbormaster failed remote builds in B58380: Diff 267127!May 28 2020, 11:57 PM
asteinhauser accepted this revision.Jun 8 2020, 11:34 AM
asteinhauser added a subscriber: asteinhauser.
asteinhauser added inline comments.
libc/utils/FPUtil/FloatOperations.h
224

Missing comma:
// If x is infinity, NaN or zero, return it.

236–242

Is this necessary?

This revision is now accepted and ready to land.Jun 8 2020, 11:34 AM
sivachandra updated this revision to Diff 269740.Jun 9 2020, 10:47 PM

Address comment.

sivachandra marked 2 inline comments as done.Jun 9 2020, 10:50 PM
sivachandra added inline comments.
libc/utils/FPUtil/FloatOperations.h
236–242

After line 250, we want exponent to be less than mantissa width, but greater than 0. So, we handle these two special cases of -1 and -2 separately.

sivachandra marked an inline comment as done.Jun 9 2020, 10:52 PM
sivachandra added inline comments.
libc/utils/FPUtil/FloatOperations.h
236–242

Actually, exponent is greater than or equal to zero and less than mantissa width after line 250.

Closed by commit rG4be1c116ad86: [libc] Add implementations of round and roundf. (authored by sivachandra). · Explain WhyJun 9 2020, 11:06 PM
This revision was automatically updated to reflect the committed changes.
Harbormaster failed remote builds in B59740: Diff 269740!Jun 9 2020, 11:25 PM

Revision Contents

PathSize
libc/
lib/
7 lines
src/
math/
35 lines
11 lines
roundf.h
round_redirector.cpp
13 lines
roundf.cpp
round_redirector.cpp
11 lines
test/
src/
math/
26 lines
84 lines
85 lines
utils/
FPUtil/
56 lines

Diff 267127

libc/lib/CMakeLists.txt

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines DEPENDS
libc.src.math.cosf libc.src.math.cosf
libc.src.math.fabs libc.src.math.fabs
libc.src.math.fabsf libc.src.math.fabsf
libc.src.math.floor libc.src.math.floor
libc.src.math.floorf libc.src.math.floorf
libc.src.math.expf libc.src.math.expf
libc.src.math.exp2f libc.src.math.exp2f
libc.src.math.round libc.src.math.round
libc.src.math.roundf
libc.src.math.sincosf libc.src.math.sincosf
libc.src.math.sinf libc.src.math.sinf
libc.src.math.trunc libc.src.math.trunc
libc.src.math.truncf libc.src.math.truncf
) )
add_redirector_library(
llvmlibc_redirectors
DEPENDS
round_redirector
)

libc/src/math/CMakeLists.txt

Show All 15 Lines HDRS
sincosf_utils.h sincosf_utils.h
SRCS SRCS
sincosf_data.cpp sincosf_data.cpp
DEPENDS DEPENDS
.math_utils .math_utils
) )
add_entrypoint_object( add_entrypoint_object(
round
REDIRECTED
SRCS
round.cpp
HDRS
round.h
)
add_redirector_object(
round_redirector
SRC
round_redirector.cpp
)
add_entrypoint_object(
cosf cosf
SRCS SRCS
cosf.cpp cosf.cpp
HDRS HDRS
cosf.h cosf.h
DEPENDS DEPENDS
.sincosf_utils .sincosf_utils
libc.include.math libc.include.math
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Linesadd_entrypoint_object(
SRCS SRCS
floorf.cpp floorf.cpp
HDRS HDRS
floorf.h floorf.h
DEPENDS DEPENDS
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_entrypoint_object(
round
SRCS
round.cpp
HDRS
round.h
DEPENDS
libc.utils.FPUtil.fputil
)
add_entrypoint_object(
roundf
SRCS
roundf.cpp
HDRS
roundf.h
DEPENDS
libc.utils.FPUtil.fputil
)
add_object_library( add_object_library(
exp_utils exp_utils
HDRS HDRS
exp_utils.h exp_utils.h
SRCS SRCS
exp_utils.cpp exp_utils.cpp
DEPENDS DEPENDS
.math_utils .math_utils
Show All 25 Lines

libc/src/math/round.cpp

//===-- Implementation of round -------------------------------------------===// //===-- Implementation of round function ----------------------------------===//
// //
// 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/round.h"
#include "src/__support/common.h" #include "src/__support/common.h"
#include "utils/FPUtil/FloatOperations.h"
namespace __llvm_libc { namespace __llvm_libc {
double __round_redirector(double x); double LLVM_LIBC_ENTRYPOINT(round)(double x) { return fputil::round(x); }
double LLVM_LIBC_ENTRYPOINT(round)(double x) {
return __round_redirector(x);
}
} // namespace __llvm_libc } // namespace __llvm_libc

libc/src/math/round_redirector.cpp

  • This file was deleted after being copied to libc/src/math/roundf.cpp, libc/src/math/roundf.h.
The contents of this file were not changed.

libc/src/math/roundf.h

  • This file was moved from libc/src/math/round_redirector.cpp.
//===-- Implementation of round redirector --------------------------------===// //===-- Implementation header for roundf ------------------------*- C++ -*-===//
// //
// 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 okay for this redirector. #ifndef LLVM_LIBC_SRC_MATH_ROUNDF_H
// NOLINTNEXTLINE(llvmlibc-restrict-system-libc-headers) #define LLVM_LIBC_SRC_MATH_ROUNDF_H
#include <math.h>
namespace __llvm_libc { namespace __llvm_libc {
double __round_redirector(double x) { float roundf(float x);
return ::round(x);
}
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_SRC_MATH_ROUNDF_H

libc/src/math/roundf.cpp

  • This file was copied from libc/src/math/round_redirector.cpp.
//===-- Implementation of round redirector --------------------------------===// //===-- Implementation of roundf function ---------------------------------===//
// //
// 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 okay for this redirector. #include "src/__support/common.h"
// NOLINTNEXTLINE(llvmlibc-restrict-system-libc-headers) #include "utils/FPUtil/FloatOperations.h"
#include <math.h>
namespace __llvm_libc { namespace __llvm_libc {
double __round_redirector(double x) { float LLVM_LIBC_ENTRYPOINT(roundf)(float x) { return fputil::round(x); }
return ::round(x);
}
} // namespace __llvm_libc } // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

Show First 20 Lines • Show All 170 Lines • ▼ Show 20 Lines SRCS
floorf_test.cpp floorf_test.cpp
DEPENDS DEPENDS
libc.include.math libc.include.math
libc.src.math.floorf libc.src.math.floorf
libc.utils.FPUtil.fputil libc.utils.FPUtil.fputil
) )
add_math_unittest( add_math_unittest(
round_test
NEED_MPFR
SUITE
libc_math_unittests
SRCS
round_test.cpp
DEPENDS
libc.include.math
libc.src.math.round
libc.utils.FPUtil.fputil
)
add_math_unittest(
roundf_test
NEED_MPFR
SUITE
libc_math_unittests
SRCS
roundf_test.cpp
DEPENDS
libc.include.math
libc.src.math.roundf
libc.utils.FPUtil.fputil
)
add_math_unittest(
expf_test expf_test
NEED_MPFR NEED_MPFR
SUITE SUITE
libc_math_unittests libc_math_unittests
SRCS SRCS
expf_test.cpp expf_test.cpp
DEPENDS DEPENDS
libc.include.errno libc.include.errno
Show All 18 Lines

libc/test/src/math/round_test.cpp

  • This file was added.
//===-- Unittests for round -----------------------------------------------===//
//
// 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 "include/math.h"
#include "src/math/round.h"
#include "utils/FPUtil/BitPatterns.h"
#include "utils/FPUtil/FloatOperations.h"
#include "utils/FPUtil/FloatProperties.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
using __llvm_libc::fputil::valueAsBits;
using __llvm_libc::fputil::valueFromBits;
using BitPatterns = __llvm_libc::fputil::BitPatterns<double>;
using Properties = __llvm_libc::fputil::FloatProperties<double>;
namespace mpfr = __llvm_libc::testing::mpfr;
// Zero tolerance; As in, exact match with MPFR result.
static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
0};
TEST(RoundTest, SpecialNumbers) {
EXPECT_EQ(
BitPatterns::aQuietNaN,
valueAsBits(__llvm_libc::round(valueFromBits(BitPatterns::aQuietNaN))));
EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
valueAsBits(__llvm_libc::round(
valueFromBits(BitPatterns::aNegativeQuietNaN))));
EXPECT_EQ(BitPatterns::aSignallingNaN,
valueAsBits(__llvm_libc::round(
valueFromBits(BitPatterns::aSignallingNaN))));
EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
valueAsBits(__llvm_libc::round(
valueFromBits(BitPatterns::aNegativeSignallingNaN))));
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::round(valueFromBits(BitPatterns::inf))));
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::round(
valueFromBits(BitPatterns::negInf))));
EXPECT_EQ(BitPatterns::zero,
valueAsBits(__llvm_libc::round(valueFromBits(BitPatterns::zero))));
EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::round(
valueFromBits(BitPatterns::negZero))));
}
TEST(RoundTest, RoundedNumbers) {
EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::round(1.0)));
EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::round(-1.0)));
EXPECT_EQ(valueAsBits(10.0), valueAsBits(__llvm_libc::round(10.0)));
EXPECT_EQ(valueAsBits(-10.0), valueAsBits(__llvm_libc::round(-10.0)));
EXPECT_EQ(valueAsBits(12345.0), valueAsBits(__llvm_libc::round(12345.0)));
EXPECT_EQ(valueAsBits(-12345.0), valueAsBits(__llvm_libc::round(-12345.0)));
}
TEST(RoundTest, CloseToZeroNumbers) {
EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::round(0.5)));
EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::round(-0.5)));
EXPECT_EQ(valueAsBits(0.0), valueAsBits(__llvm_libc::round(0.115)));
EXPECT_EQ(valueAsBits(-0.0), valueAsBits(__llvm_libc::round(-0.115)));
EXPECT_EQ(valueAsBits(1.0), valueAsBits(__llvm_libc::round(0.715)));
EXPECT_EQ(valueAsBits(-1.0), valueAsBits(__llvm_libc::round(-0.715)));
}
TEST(RoundTest, InDoubleRange) {
using BitsType = Properties::BitsType;
constexpr BitsType count = 1000000;
constexpr BitsType step = UINT64_MAX / count;
for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
double x = valueFromBits(v);
if (isnan(x) || isinf(x))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::round(x),
tolerance);
}
}

libc/test/src/math/roundf_test.cpp

  • This file was added.
//===-- Unittests for roundf ----------------------------------------------===//
//
// 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 "include/math.h"
#include "src/math/roundf.h"
#include "utils/FPUtil/BitPatterns.h"
#include "utils/FPUtil/FloatOperations.h"
#include "utils/FPUtil/FloatProperties.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include "utils/UnitTest/Test.h"
using __llvm_libc::fputil::valueAsBits;
using __llvm_libc::fputil::valueFromBits;
using BitPatterns = __llvm_libc::fputil::BitPatterns<float>;
using Properties = __llvm_libc::fputil::FloatProperties<float>;
namespace mpfr = __llvm_libc::testing::mpfr;
// Zero tolerance; As in, exact match with MPFR result.
static constexpr mpfr::Tolerance tolerance{mpfr::Tolerance::doublePrecision, 0,
0};
TEST(RoundfTest, SpecialNumbers) {
EXPECT_EQ(
BitPatterns::aQuietNaN,
valueAsBits(__llvm_libc::roundf(valueFromBits(BitPatterns::aQuietNaN))));
EXPECT_EQ(BitPatterns::aNegativeQuietNaN,
valueAsBits(__llvm_libc::roundf(
valueFromBits(BitPatterns::aNegativeQuietNaN))));
EXPECT_EQ(BitPatterns::aSignallingNaN,
valueAsBits(__llvm_libc::roundf(
valueFromBits(BitPatterns::aSignallingNaN))));
EXPECT_EQ(BitPatterns::aNegativeSignallingNaN,
valueAsBits(__llvm_libc::roundf(
valueFromBits(BitPatterns::aNegativeSignallingNaN))));
EXPECT_EQ(BitPatterns::inf,
valueAsBits(__llvm_libc::roundf(valueFromBits(BitPatterns::inf))));
EXPECT_EQ(BitPatterns::negInf, valueAsBits(__llvm_libc::roundf(
valueFromBits(BitPatterns::negInf))));
EXPECT_EQ(BitPatterns::zero,
valueAsBits(__llvm_libc::roundf(valueFromBits(BitPatterns::zero))));
EXPECT_EQ(BitPatterns::negZero, valueAsBits(__llvm_libc::roundf(
valueFromBits(BitPatterns::negZero))));
}
TEST(RoundfTest, RoundedNumbers) {
EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::roundf(1.0f)));
EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::roundf(-1.0f)));
EXPECT_EQ(valueAsBits(10.0f), valueAsBits(__llvm_libc::roundf(10.0f)));
EXPECT_EQ(valueAsBits(-10.0f), valueAsBits(__llvm_libc::roundf(-10.0f)));
EXPECT_EQ(valueAsBits(12345.0f), valueAsBits(__llvm_libc::roundf(12345.0f)));
EXPECT_EQ(valueAsBits(-12345.0f),
valueAsBits(__llvm_libc::roundf(-12345.0f)));
}
TEST(RoundTest, CloseToZeroNumbers) {
EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::roundf(0.5f)));
EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::roundf(-0.5f)));
EXPECT_EQ(valueAsBits(0.0f), valueAsBits(__llvm_libc::roundf(0.115f)));
EXPECT_EQ(valueAsBits(-0.0f), valueAsBits(__llvm_libc::roundf(-0.115f)));
EXPECT_EQ(valueAsBits(1.0f), valueAsBits(__llvm_libc::roundf(0.715f)));
EXPECT_EQ(valueAsBits(-1.0f), valueAsBits(__llvm_libc::roundf(-0.715f)));
}
TEST(RoundfTest, InFloatRange) {
using BitsType = Properties::BitsType;
constexpr BitsType count = 1000000;
constexpr BitsType step = UINT32_MAX / count;
for (BitsType i = 0, v = 0; i <= count; ++i, v += step) {
double x = valueFromBits(v);
if (isnan(x) || isinf(x))
continue;
ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, __llvm_libc::roundf(x),
tolerance);
}
}

libc/utils/FPUtil/FloatOperations.h

Show First 20 Lines • Show All 207 Lines • ▼ Show 20 Linesstatic inline T floor(T x) {
auto bits = valueAsBits(x); auto bits = valueAsBits(x);
if (FloatProperties<T>::signMask & bits) { if (FloatProperties<T>::signMask & bits) {
return -ceil(-x); return -ceil(-x);
} else { } else {
return trunc(x); return trunc(x);
} }
} }
template <typename T,
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
static inline T round(T x) {
using Properties = FloatProperties<T>;
using BitsType = typename FloatProperties<T>::BitsType;
BitsType bits = valueAsBits(x);
// If x is infinity NaN or zero, return it.
asteinhauserUnsubmitted
Done
ReplyInline Actions

Missing comma:
// If x is infinity, NaN or zero, return it.

asteinhauser: Missing comma: // If x is infinity, NaN or zero, return it.
if (bitsAreInfOrNaN(bits) || bitsAreZero(bits))
return x;
bool isNeg = bits & Properties::signMask;
int exponent = getExponentFromBits(bits);
// If the exponent is greater than the most negative mantissa
// exponent, then x is already an integer.
if (exponent >= static_cast<int>(Properties::mantissaWidth))
return x;
if (exponent == -1) {
// Absolute value of x is greater than equal to 0.5 but less than 1.
if (isNeg)
return T(-1.0);
else
return T(1.0);
}
asteinhauserUnsubmitted
Not Done
ReplyInline Actions

Is this necessary?

asteinhauser: Is this necessary?
sivachandraAuthorUnsubmitted
Done
ReplyInline Actions

After line 250, we want exponent to be less than mantissa width, but greater than 0. So, we handle these two special cases of -1 and -2 separately.

sivachandra: After line 250, we want `exponent` to be less than mantissa width, but greater than 0. So, we…
sivachandraAuthorUnsubmitted
Done
ReplyInline Actions

Actually, exponent is greater than or equal to zero and less than mantissa width after line 250.

sivachandra: Actually, `exponent` is greater than **or equal to** zero and less than mantissa width after…
if (exponent <= -2) {
// Absolute value of x is less than equal to 0.5.
if (isNeg)
return T(-0.0);
else
return T(0.0);
}
uint32_t trimSize = Properties::mantissaWidth - exponent;
// If x is already an integer, return it.
if ((bits << (Properties::bitWidth - trimSize)) == 0)
return x;
BitsType truncBits = (bits >> trimSize) << trimSize;
T truncValue = valueFromBits(truncBits);
if ((bits & (BitsType(1) << (trimSize - 1))) == 0) {
// Franctional part is less than 0.5 so round value is the
// same as the trunc value.
return truncValue;
}
if (isNeg)
return truncValue - T(1.0);
else
return truncValue + T(1.0);
}
} // namespace fputil } // namespace fputil
} // namespace __llvm_libc } // namespace __llvm_libc
#endif // LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H #endif // LLVM_LIBC_UTILS_FPUTIL_FLOAT_OPERATIONS_H