Export of internal Abseil changes
--
e54b9c7bbb0c58475676c268e2e19c69f4bce48a by Jorg Brown <jorg@google.com>:
Tweak ABSL_PREDICT_TRUE slightly, for better code on some platforms and/or
optimization levels. "false || (x)" is more verbose than "!!(x)", but
ultimately more efficient.
For example, given this code:
void InitIfNecessary() {
if (ABSL_PREDICT_TRUE(NeedsInit())) {
SlowInitIfNecessary();
}
}
Clang with default optimization level will produce:
Before this CL After this CL
InitIfNecessary: InitIfNecessary:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
call NeedsInit call NeedsInit
xor al, -1
xor al, -1
test al, 1 test al, 1
jne .LBB2_1 jne .LBB3_1
jmp .LBB2_2 jmp .LBB3_2
.LBB2_1: .LBB3_1:
call SlowInitIfNecessary call SlowInitIfNecessary
.LBB2_2: .LBB3_2:
pop rbp pop rbp
ret ret
PiperOrigin-RevId: 276401386
--
0a3c4dfd8342bf2b1b11a87f1c662c883f73cab7 by Abseil Team <absl-team@google.com>:
Fix comment nit: sem_open => sem_init.
The code calls sem_init, not sem_open, to initialize an unnamed semaphore.
(sem_open creates or opens a named semaphore.)
PiperOrigin-RevId: 276344072
--
b36a664e9459057509a90e83d3482e1d3a4c44c7 by Abseil Team <absl-team@google.com>:
Fix typo in flat_hash_map.h: exchaged -> exchanged
PiperOrigin-RevId: 276295792
--
7bbd8d18276eb110c8335743e35fceb662ddf3d6 by Samuel Benzaquen <sbenza@google.com>:
Add assertions to verify use of iterators.
PiperOrigin-RevId: 276283300
--
677398a8ffcb1f59182cffe57a4fe7ff147a0404 by Laramie Leavitt <lar@google.com>:
Migrate distribution_impl.h/cc to generate_real.h/cc.
Combine the methods RandU64To<Float,Double> into a single method:
GenerateRealFromBits().
Remove rejection sampling from absl::uniform_real_distribution.
PiperOrigin-RevId: 276158675
--
c60c9d11d24b0c546329d998e78e15a84b3153f5 by Abseil Team <absl-team@google.com>:
Internal change
PiperOrigin-RevId: 276126962
--
4c840cab6a8d86efa29b397cafaf7520eece68cc by Andy Soffer <asoffer@google.com>:
Update CMakeLists.txt to address https://github.com/abseil/abseil-cpp/issues/365.
This does not cover every platform, but it does at least address the
first-order issue of assuming gcc implies x86.
PiperOrigin-RevId: 276116253
--
98da366e6b5d51afe5d7ac6722126aca23d85ee6 by Abseil Team <absl-team@google.com>:
Internal change
PiperOrigin-RevId: 276097452
GitOrigin-RevId: e54b9c7bbb0c58475676c268e2e19c69f4bce48a
Change-Id: I02d84454bb71ab21ad3d39650acf6cc6e36f58d7
This commit is contained in:
Abseil Team
Derek Mauro
parent
19b021cb3f
commit
078b89b3c0
28 changed files with 739 additions and 370 deletions
|
|
@ -175,9 +175,9 @@ cc_library(
|
|||
)
|
||||
|
||||
cc_library(
|
||||
name = "distribution_impl",
|
||||
name = "generate_real",
|
||||
hdrs = [
|
||||
"distribution_impl.h",
|
||||
"generate_real.h",
|
||||
],
|
||||
copts = ABSL_DEFAULT_COPTS,
|
||||
linkopts = ABSL_DEFAULT_LINKOPTS,
|
||||
|
|
@ -185,8 +185,7 @@ cc_library(
|
|||
":fastmath",
|
||||
":traits",
|
||||
"//absl/base:bits",
|
||||
"//absl/base:config",
|
||||
"//absl/numeric:int128",
|
||||
"//absl/meta:type_traits",
|
||||
],
|
||||
)
|
||||
|
||||
|
|
@ -398,16 +397,17 @@ cc_test(
|
|||
)
|
||||
|
||||
cc_test(
|
||||
name = "distribution_impl_test",
|
||||
name = "generate_real_test",
|
||||
size = "small",
|
||||
srcs = ["distribution_impl_test.cc"],
|
||||
srcs = [
|
||||
"generate_real_test.cc",
|
||||
],
|
||||
copts = ABSL_TEST_COPTS,
|
||||
linkopts = ABSL_DEFAULT_LINKOPTS,
|
||||
deps = [
|
||||
":distribution_impl",
|
||||
":generate_real",
|
||||
"//absl/base:bits",
|
||||
"//absl/flags:flag",
|
||||
"//absl/numeric:int128",
|
||||
"@com_google_googletest//:gtest_main",
|
||||
],
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,194 +0,0 @@
|
|||
// Copyright 2017 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef ABSL_RANDOM_INTERNAL_DISTRIBUTION_IMPL_H_
|
||||
#define ABSL_RANDOM_INTERNAL_DISTRIBUTION_IMPL_H_
|
||||
|
||||
// This file contains some implementation details which are used by one or more
|
||||
// of the absl random number distributions.
|
||||
|
||||
#include <cfloat>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
|
||||
#if (defined(_WIN32) || defined(_WIN64)) && defined(_M_IA64)
|
||||
#include <intrin.h> // NOLINT(build/include_order)
|
||||
#pragma intrinsic(_umul128)
|
||||
#define ABSL_INTERNAL_USE_UMUL128 1
|
||||
#endif
|
||||
|
||||
#include "absl/base/config.h"
|
||||
#include "absl/base/internal/bits.h"
|
||||
#include "absl/numeric/int128.h"
|
||||
#include "absl/random/internal/fastmath.h"
|
||||
#include "absl/random/internal/traits.h"
|
||||
|
||||
namespace absl {
|
||||
namespace random_internal {
|
||||
|
||||
// Creates a double from `bits`, with the template fields controlling the
|
||||
// output.
|
||||
//
|
||||
// RandU64To is both more efficient and generates more unique values in the
|
||||
// result interval than known implementations of std::generate_canonical().
|
||||
//
|
||||
// The `Signed` parameter controls whether positive, negative, or both are
|
||||
// returned (thus affecting the output interval).
|
||||
// When Signed == SignedValueT, range is U(-1, 1)
|
||||
// When Signed == NegativeValueT, range is U(-1, 0)
|
||||
// When Signed == PositiveValueT, range is U(0, 1)
|
||||
//
|
||||
// When the `IncludeZero` parameter is true, the function may return 0 for some
|
||||
// inputs, otherwise it never returns 0.
|
||||
//
|
||||
// The `ExponentBias` parameter determines the scale of the output range by
|
||||
// adjusting the exponent.
|
||||
//
|
||||
// When a value in U(0,1) is required, use:
|
||||
// RandU64ToDouble<PositiveValueT, true, 0>();
|
||||
//
|
||||
// When a value in U(-1,1) is required, use:
|
||||
// RandU64ToDouble<SignedValueT, false, 0>() => U(-1, 1)
|
||||
// This generates more distinct values than the mathematically equivalent
|
||||
// expression `U(0, 1) * 2.0 - 1.0`, and is preferable.
|
||||
//
|
||||
// Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
|
||||
// RandU64ToDouble<PositiveValueT, false, 1>(); => U(0, 2)
|
||||
// RandU64ToDouble<PositiveValueT, false, -1>(); => U(0, 0.5)
|
||||
//
|
||||
|
||||
// Tristate types controlling the output.
|
||||
struct PositiveValueT {};
|
||||
struct NegativeValueT {};
|
||||
struct SignedValueT {};
|
||||
|
||||
// RandU64ToDouble is the double-result variant of RandU64To, described above.
|
||||
template <typename Signed, bool IncludeZero, int ExponentBias = 0>
|
||||
inline double RandU64ToDouble(uint64_t bits) {
|
||||
static_assert(std::is_same<Signed, PositiveValueT>::value ||
|
||||
std::is_same<Signed, NegativeValueT>::value ||
|
||||
std::is_same<Signed, SignedValueT>::value,
|
||||
"");
|
||||
|
||||
// Maybe use the left-most bit for a sign bit.
|
||||
uint64_t sign = std::is_same<Signed, NegativeValueT>::value
|
||||
? 0x8000000000000000ull
|
||||
: 0; // Sign bits.
|
||||
|
||||
if (std::is_same<Signed, SignedValueT>::value) {
|
||||
sign = bits & 0x8000000000000000ull;
|
||||
bits = bits & 0x7FFFFFFFFFFFFFFFull;
|
||||
}
|
||||
if (IncludeZero) {
|
||||
if (bits == 0u) return 0;
|
||||
}
|
||||
|
||||
// Number of leading zeros is mapped to the exponent: 2^-clz
|
||||
int clz = base_internal::CountLeadingZeros64(bits);
|
||||
// Shift number left to erase leading zeros.
|
||||
bits <<= IncludeZero ? clz : (clz & 63);
|
||||
|
||||
// Shift number right to remove bits that overflow double mantissa. The
|
||||
// direction of the shift depends on `clz`.
|
||||
bits >>= (64 - DBL_MANT_DIG);
|
||||
|
||||
// Compute IEEE 754 double exponent.
|
||||
// In the Signed case, bits is a 63-bit number with a 0 msb. Adjust the
|
||||
// exponent to account for that.
|
||||
const uint64_t exp =
|
||||
(std::is_same<Signed, SignedValueT>::value ? 1023U : 1022U) +
|
||||
static_cast<uint64_t>(ExponentBias - clz);
|
||||
constexpr int kExp = DBL_MANT_DIG - 1;
|
||||
// Construct IEEE 754 double from exponent and mantissa.
|
||||
const uint64_t val = sign | (exp << kExp) | (bits & ((1ULL << kExp) - 1U));
|
||||
|
||||
double res;
|
||||
static_assert(sizeof(res) == sizeof(val), "double is not 64 bit");
|
||||
// Memcpy value from "val" to "res" to avoid aliasing problems. Assumes that
|
||||
// endian-ness is same for double and uint64_t.
|
||||
std::memcpy(&res, &val, sizeof(res));
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
// RandU64ToFloat is the float-result variant of RandU64To, described above.
|
||||
template <typename Signed, bool IncludeZero, int ExponentBias = 0>
|
||||
inline float RandU64ToFloat(uint64_t bits) {
|
||||
static_assert(std::is_same<Signed, PositiveValueT>::value ||
|
||||
std::is_same<Signed, NegativeValueT>::value ||
|
||||
std::is_same<Signed, SignedValueT>::value,
|
||||
"");
|
||||
|
||||
// Maybe use the left-most bit for a sign bit.
|
||||
uint64_t sign = std::is_same<Signed, NegativeValueT>::value
|
||||
? 0x80000000ul
|
||||
: 0; // Sign bits.
|
||||
|
||||
if (std::is_same<Signed, SignedValueT>::value) {
|
||||
uint64_t a = bits & 0x8000000000000000ull;
|
||||
sign = static_cast<uint32_t>(a >> 32);
|
||||
bits = bits & 0x7FFFFFFFFFFFFFFFull;
|
||||
}
|
||||
if (IncludeZero) {
|
||||
if (bits == 0u) return 0;
|
||||
}
|
||||
|
||||
// Number of leading zeros is mapped to the exponent: 2^-clz
|
||||
int clz = base_internal::CountLeadingZeros64(bits);
|
||||
// Shift number left to erase leading zeros.
|
||||
bits <<= IncludeZero ? clz : (clz & 63);
|
||||
// Shift number right to remove bits that overflow double mantissa. The
|
||||
// direction of the shift depends on `clz`.
|
||||
bits >>= (64 - FLT_MANT_DIG);
|
||||
|
||||
// Construct IEEE 754 float exponent.
|
||||
// In the Signed case, bits is a 63-bit number with a 0 msb. Adjust the
|
||||
// exponent to account for that.
|
||||
const uint32_t exp =
|
||||
(std::is_same<Signed, SignedValueT>::value ? 127U : 126U) +
|
||||
static_cast<uint32_t>(ExponentBias - clz);
|
||||
constexpr int kExp = FLT_MANT_DIG - 1;
|
||||
const uint32_t val = sign | (exp << kExp) | (bits & ((1U << kExp) - 1U));
|
||||
|
||||
float res;
|
||||
static_assert(sizeof(res) == sizeof(val), "float is not 32 bit");
|
||||
// Assumes that endian-ness is same for float and uint32_t.
|
||||
std::memcpy(&res, &val, sizeof(res));
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
template <typename Result>
|
||||
struct RandU64ToReal {
|
||||
template <typename Signed, bool IncludeZero, int ExponentBias = 0>
|
||||
static inline Result Value(uint64_t bits) {
|
||||
return RandU64ToDouble<Signed, IncludeZero, ExponentBias>(bits);
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct RandU64ToReal<float> {
|
||||
template <typename Signed, bool IncludeZero, int ExponentBias = 0>
|
||||
static inline float Value(uint64_t bits) {
|
||||
return RandU64ToFloat<Signed, IncludeZero, ExponentBias>(bits);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace random_internal
|
||||
} // namespace absl
|
||||
|
||||
#endif // ABSL_RANDOM_INTERNAL_DISTRIBUTION_IMPL_H_
|
||||
144
absl/random/internal/generate_real.h
Normal file
144
absl/random/internal/generate_real.h
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
// Copyright 2017 The Abseil Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
|
||||
#define ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
|
||||
|
||||
// This file contains some implementation details which are used by one or more
|
||||
// of the absl random number distributions.
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
|
||||
#include "absl/base/internal/bits.h"
|
||||
#include "absl/meta/type_traits.h"
|
||||
#include "absl/random/internal/fastmath.h"
|
||||
#include "absl/random/internal/traits.h"
|
||||
|
||||
namespace absl {
|
||||
namespace random_internal {
|
||||
|
||||
// Tristate tag types controlling the output of GenerateRealFromBits.
|
||||
struct GeneratePositiveTag {};
|
||||
struct GenerateNegativeTag {};
|
||||
struct GenerateSignedTag {};
|
||||
|
||||
// GenerateRealFromBits generates a single real value from a single 64-bit
|
||||
// `bits` with template fields controlling the output.
|
||||
//
|
||||
// The `SignedTag` parameter controls whether positive, negative,
|
||||
// or either signed/unsigned may be returned.
|
||||
// When SignedTag == GeneratePositiveTag, range is U(0, 1)
|
||||
// When SignedTag == GenerateNegativeTag, range is U(-1, 0)
|
||||
// When SignedTag == GenerateSignedTag, range is U(-1, 1)
|
||||
//
|
||||
// When the `IncludeZero` parameter is true, the function may return 0 for some
|
||||
// inputs, otherwise it never returns 0.
|
||||
//
|
||||
// When a value in U(0,1) is required, use:
|
||||
// Uniform64ToReal<double, PositiveValueT, true>;
|
||||
//
|
||||
// When a value in U(-1,1) is required, use:
|
||||
// Uniform64ToReal<double, SignedValueT, false>;
|
||||
//
|
||||
// This generates more distinct values than the mathematical equivalent
|
||||
// `U(0, 1) * 2.0 - 1.0`.
|
||||
//
|
||||
// Scaling the result by powers of 2 (and avoiding a multiply) is also possible:
|
||||
// GenerateRealFromBits<double>(..., -1); => U(0, 0.5)
|
||||
// GenerateRealFromBits<double>(..., 1); => U(0, 2)
|
||||
//
|
||||
template <typename RealType, // Real type, either float or double.
|
||||
typename SignedTag = GeneratePositiveTag, // Whether a positive,
|
||||
// negative, or signed
|
||||
// value is generated.
|
||||
bool IncludeZero = true>
|
||||
inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0) {
|
||||
using real_type = RealType;
|
||||
using uint_type = absl::conditional_t<std::is_same<real_type, float>::value,
|
||||
uint32_t, uint64_t>;
|
||||
|
||||
static_assert(
|
||||
(std::is_same<double, real_type>::value ||
|
||||
std::is_same<float, real_type>::value),
|
||||
"GenerateRealFromBits must be parameterized by either float or double.");
|
||||
|
||||
static_assert(sizeof(uint_type) == sizeof(real_type),
|
||||
"Mismatched unsinged and real types.");
|
||||
|
||||
static_assert((std::numeric_limits<real_type>::is_iec559 &&
|
||||
std::numeric_limits<real_type>::radix == 2),
|
||||
"RealType representation is not IEEE 754 binary.");
|
||||
|
||||
static_assert((std::is_same<SignedTag, GeneratePositiveTag>::value ||
|
||||
std::is_same<SignedTag, GenerateNegativeTag>::value ||
|
||||
std::is_same<SignedTag, GenerateSignedTag>::value),
|
||||
"");
|
||||
|
||||
static constexpr int kExp = std::numeric_limits<real_type>::digits - 1;
|
||||
static constexpr uint_type kMask = (static_cast<uint_type>(1) << kExp) - 1u;
|
||||
static constexpr int kUintBits = sizeof(uint_type) * 8;
|
||||
|
||||
int exp = exp_bias + int{std::numeric_limits<real_type>::max_exponent - 2};
|
||||
|
||||
// Determine the sign bit.
|
||||
// Depending on the SignedTag, this may use the left-most bit
|
||||
// or it may be a constant value.
|
||||
uint_type sign = std::is_same<SignedTag, GenerateNegativeTag>::value
|
||||
? (static_cast<uint_type>(1) << (kUintBits - 1))
|
||||
: 0;
|
||||
if (std::is_same<SignedTag, GenerateSignedTag>::value) {
|
||||
if (std::is_same<uint_type, uint64_t>::value) {
|
||||
sign = bits & uint64_t{0x8000000000000000};
|
||||
}
|
||||
if (std::is_same<uint_type, uint32_t>::value) {
|
||||
const uint64_t tmp = bits & uint64_t{0x8000000000000000};
|
||||
sign = static_cast<uint32_t>(tmp >> 32);
|
||||
}
|
||||
// adjust the bits and the exponent to account for removing
|
||||
// the leading bit.
|
||||
bits = bits & uint64_t{0x7FFFFFFFFFFFFFFF};
|
||||
exp++;
|
||||
}
|
||||
if (IncludeZero) {
|
||||
if (bits == 0u) return 0;
|
||||
}
|
||||
|
||||
// Number of leading zeros is mapped to the exponent: 2^-clz
|
||||
// bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
|
||||
int clz = base_internal::CountLeadingZeros64(bits);
|
||||
bits <<= (IncludeZero ? clz : (clz & 63)); // remove 0-bits.
|
||||
exp -= clz; // set the exponent.
|
||||
bits >>= (63 - kExp);
|
||||
|
||||
// Construct the 32-bit or 64-bit IEEE 754 floating-point value from
|
||||
// the individual fields: sign, exp, mantissa(bits).
|
||||
uint_type val =
|
||||
(std::is_same<SignedTag, GeneratePositiveTag>::value ? 0u : sign) |
|
||||
(static_cast<uint_type>(exp) << kExp) |
|
||||
(static_cast<uint_type>(bits) & kMask);
|
||||
|
||||
// bit_cast to the output-type
|
||||
real_type result;
|
||||
memcpy(static_cast<void*>(&result), static_cast<const void*>(&val),
|
||||
sizeof(result));
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace random_internal
|
||||
} // namespace absl
|
||||
|
||||
#endif // ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
|
||||
|
|
@ -12,57 +12,74 @@
|
|||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "absl/random/internal/distribution_impl.h"
|
||||
#include "absl/random/internal/generate_real.h"
|
||||
|
||||
#include <cfloat>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include "absl/base/internal/bits.h"
|
||||
#include "absl/flags/flag.h"
|
||||
#include "absl/numeric/int128.h"
|
||||
|
||||
ABSL_FLAG(int64_t, absl_random_test_trials, 50000,
|
||||
"Number of trials for the probability tests.");
|
||||
|
||||
using absl::random_internal::NegativeValueT;
|
||||
using absl::random_internal::PositiveValueT;
|
||||
using absl::random_internal::RandU64ToDouble;
|
||||
using absl::random_internal::RandU64ToFloat;
|
||||
using absl::random_internal::SignedValueT;
|
||||
using absl::random_internal::GenerateNegativeTag;
|
||||
using absl::random_internal::GeneratePositiveTag;
|
||||
using absl::random_internal::GenerateRealFromBits;
|
||||
using absl::random_internal::GenerateSignedTag;
|
||||
|
||||
namespace {
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloat_Positive_NoZero_Test) {
|
||||
TEST(GenerateRealTest, U64ToFloat_Positive_NoZero_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<PositiveValueT, false>(a);
|
||||
return GenerateRealFromBits<float, GeneratePositiveTag, false>(a);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 2.710505431e-20f);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), 5.421010862e-20f);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000000), 0.5);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000001), 0.5);
|
||||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), 0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloat_Positive_Zero_Test) {
|
||||
TEST(GenerateRealTest, U64ToFloat_Positive_Zero_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<PositiveValueT, true>(a);
|
||||
return GenerateRealFromBits<float, GeneratePositiveTag, true>(a);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 0.0);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), 5.421010862e-20f);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000000), 0.5);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000001), 0.5);
|
||||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), 0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloat_Negative_NoZero_Test) {
|
||||
TEST(GenerateRealTest, U64ToFloat_Negative_NoZero_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<NegativeValueT, false>(a);
|
||||
return GenerateRealFromBits<float, GenerateNegativeTag, false>(a);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), -2.710505431e-20f);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), -5.421010862e-20f);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000000), -0.5);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000001), -0.5);
|
||||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloat_Signed_NoZero_Test) {
|
||||
TEST(GenerateRealTest, U64ToFloat_Negative_Zero_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<SignedValueT, false>(a);
|
||||
return GenerateRealFromBits<float, GenerateNegativeTag, true>(a);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 0.0);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), -5.421010862e-20f);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000000), -0.5);
|
||||
EXPECT_EQ(ToFloat(0x8000000000000001), -0.5);
|
||||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(GenerateRealTest, U64ToFloat_Signed_NoZero_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return GenerateRealFromBits<float, GenerateSignedTag, false>(a);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 5.421010862e-20f);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), 1.084202172e-19f);
|
||||
|
|
@ -72,9 +89,9 @@ TEST(DistributionImplTest, U64ToFloat_Signed_NoZero_Test) {
|
|||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloat_Signed_Zero_Test) {
|
||||
TEST(GenerateRealTest, U64ToFloat_Signed_Zero_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<SignedValueT, true>(a);
|
||||
return GenerateRealFromBits<float, GenerateSignedTag, true>(a);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 0);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), 1.084202172e-19f);
|
||||
|
|
@ -84,9 +101,9 @@ TEST(DistributionImplTest, U64ToFloat_Signed_Zero_Test) {
|
|||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), -0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloat_Signed_Bias_Test) {
|
||||
TEST(GenerateRealTest, U64ToFloat_Signed_Bias_Test) {
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<SignedValueT, true, 1>(a);
|
||||
return GenerateRealFromBits<float, GenerateSignedTag, true>(a, 1);
|
||||
};
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 0);
|
||||
EXPECT_EQ(ToFloat(0x0000000000000001), 2 * 1.084202172e-19f);
|
||||
|
|
@ -96,9 +113,9 @@ TEST(DistributionImplTest, U64ToFloat_Signed_Bias_Test) {
|
|||
EXPECT_EQ(ToFloat(0xFFFFFFFFFFFFFFFF), 2 * -0.9999999404f);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToFloatTest) {
|
||||
TEST(GenerateRealTest, U64ToFloatTest) {
|
||||
auto ToFloat = [](uint64_t a) -> float {
|
||||
return RandU64ToFloat<PositiveValueT, true>(a);
|
||||
return GenerateRealFromBits<float, GeneratePositiveTag, true>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToFloat(0x0000000000000000), 0.0f);
|
||||
|
|
@ -150,44 +167,60 @@ TEST(DistributionImplTest, U64ToFloatTest) {
|
|||
}
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDouble_Positive_NoZero_Test) {
|
||||
TEST(GenerateRealTest, U64ToDouble_Positive_NoZero_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<PositiveValueT, false>(a);
|
||||
return GenerateRealFromBits<double, GeneratePositiveTag, false>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 2.710505431213761085e-20);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000001), 5.42101086242752217004e-20);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000002), 1.084202172485504434e-19);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000000), 0.5);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000001), 0.5);
|
||||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), 0.999999999999999888978);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDouble_Positive_Zero_Test) {
|
||||
TEST(GenerateRealTest, U64ToDouble_Positive_Zero_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<PositiveValueT, true>(a);
|
||||
return GenerateRealFromBits<double, GeneratePositiveTag, true>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 0.0);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000001), 5.42101086242752217004e-20);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000000), 0.5);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000001), 0.5);
|
||||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), 0.999999999999999888978);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDouble_Negative_NoZero_Test) {
|
||||
TEST(GenerateRealTest, U64ToDouble_Negative_NoZero_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<NegativeValueT, false>(a);
|
||||
return GenerateRealFromBits<double, GenerateNegativeTag, false>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), -2.710505431213761085e-20);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000001), -5.42101086242752217004e-20);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000002), -1.084202172485504434e-19);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000000), -0.5);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000001), -0.5);
|
||||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDouble_Signed_NoZero_Test) {
|
||||
TEST(GenerateRealTest, U64ToDouble_Negative_Zero_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<SignedValueT, false>(a);
|
||||
return GenerateRealFromBits<double, GenerateNegativeTag, true>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 0.0);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000001), -5.42101086242752217004e-20);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000002), -1.084202172485504434e-19);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000000), -0.5);
|
||||
EXPECT_EQ(ToDouble(0x8000000000000001), -0.5);
|
||||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
|
||||
}
|
||||
|
||||
TEST(GenerateRealTest, U64ToDouble_Signed_NoZero_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return GenerateRealFromBits<double, GenerateSignedTag, false>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 5.42101086242752217004e-20);
|
||||
|
|
@ -198,9 +231,9 @@ TEST(DistributionImplTest, U64ToDouble_Signed_NoZero_Test) {
|
|||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDouble_Signed_Zero_Test) {
|
||||
TEST(GenerateRealTest, U64ToDouble_Signed_Zero_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<SignedValueT, true>(a);
|
||||
return GenerateRealFromBits<double, GenerateSignedTag, true>(a);
|
||||
};
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 0);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000001), 1.084202172485504434e-19);
|
||||
|
|
@ -210,9 +243,9 @@ TEST(DistributionImplTest, U64ToDouble_Signed_Zero_Test) {
|
|||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDouble_Signed_Bias_Test) {
|
||||
TEST(GenerateRealTest, U64ToDouble_GenerateSignedTag_Bias_Test) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<SignedValueT, true, -1>(a);
|
||||
return GenerateRealFromBits<double, GenerateSignedTag, true>(a, -1);
|
||||
};
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 0);
|
||||
EXPECT_EQ(ToDouble(0x0000000000000001), 1.084202172485504434e-19 / 2);
|
||||
|
|
@ -222,9 +255,9 @@ TEST(DistributionImplTest, U64ToDouble_Signed_Bias_Test) {
|
|||
EXPECT_EQ(ToDouble(0xFFFFFFFFFFFFFFFF), -0.999999999999999888978 / 2);
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDoubleTest) {
|
||||
TEST(GenerateRealTest, U64ToDoubleTest) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<PositiveValueT, true>(a);
|
||||
return GenerateRealFromBits<double, GeneratePositiveTag, true>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 0.0);
|
||||
|
|
@ -296,9 +329,9 @@ TEST(DistributionImplTest, U64ToDoubleTest) {
|
|||
}
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, U64ToDoubleSignedTest) {
|
||||
TEST(GenerateRealTest, U64ToDoubleSignedTest) {
|
||||
auto ToDouble = [](uint64_t a) {
|
||||
return RandU64ToDouble<SignedValueT, false>(a);
|
||||
return GenerateRealFromBits<double, GenerateSignedTag, false>(a);
|
||||
};
|
||||
|
||||
EXPECT_EQ(ToDouble(0x0000000000000000), 5.42101086242752217004e-20);
|
||||
|
|
@ -379,10 +412,10 @@ TEST(DistributionImplTest, U64ToDoubleSignedTest) {
|
|||
}
|
||||
}
|
||||
|
||||
TEST(DistributionImplTest, ExhaustiveFloat) {
|
||||
TEST(GenerateRealTest, ExhaustiveFloat) {
|
||||
using absl::base_internal::CountLeadingZeros64;
|
||||
auto ToFloat = [](uint64_t a) {
|
||||
return RandU64ToFloat<PositiveValueT, true>(a);
|
||||
return GenerateRealFromBits<float, GeneratePositiveTag, true>(a);
|
||||
};
|
||||
|
||||
// Rely on RandU64ToFloat generating values from greatest to least when
|
||||
Loading…
Add table
Add a link
Reference in a new issue