145 lines
5.5 KiB
C++
145 lines
5.5 KiB
C++
// 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/meta/type_traits.h"
|
|
#include "absl/numeric/bits.h"
|
|
#include "absl/random/internal/fastmath.h"
|
|
#include "absl/random/internal/traits.h"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
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:
|
|
// GenerateRealFromBits<double, PositiveValueT, true>;
|
|
//
|
|
// When a value in U(-1,1) is required, use:
|
|
// GenerateRealFromBits<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 = countl_zero(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 = 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
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|
|
|
|
#endif // ABSL_RANDOM_INTERNAL_GENERATE_REAL_H_
|