078b89b3c0
-- 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
163 lines
5.3 KiB
C++
163 lines
5.3 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_EXPONENTIAL_DISTRIBUTION_H_
|
|
#define ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
|
|
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <istream>
|
|
#include <limits>
|
|
#include <type_traits>
|
|
|
|
#include "absl/meta/type_traits.h"
|
|
#include "absl/random/internal/fast_uniform_bits.h"
|
|
#include "absl/random/internal/generate_real.h"
|
|
#include "absl/random/internal/iostream_state_saver.h"
|
|
|
|
namespace absl {
|
|
|
|
// absl::exponential_distribution:
|
|
// Generates a number conforming to an exponential distribution and is
|
|
// equivalent to the standard [rand.dist.pois.exp] distribution.
|
|
template <typename RealType = double>
|
|
class exponential_distribution {
|
|
public:
|
|
using result_type = RealType;
|
|
|
|
class param_type {
|
|
public:
|
|
using distribution_type = exponential_distribution;
|
|
|
|
explicit param_type(result_type lambda = 1) : lambda_(lambda) {
|
|
assert(lambda > 0);
|
|
neg_inv_lambda_ = -result_type(1) / lambda_;
|
|
}
|
|
|
|
result_type lambda() const { return lambda_; }
|
|
|
|
friend bool operator==(const param_type& a, const param_type& b) {
|
|
return a.lambda_ == b.lambda_;
|
|
}
|
|
|
|
friend bool operator!=(const param_type& a, const param_type& b) {
|
|
return !(a == b);
|
|
}
|
|
|
|
private:
|
|
friend class exponential_distribution;
|
|
|
|
result_type lambda_;
|
|
result_type neg_inv_lambda_;
|
|
|
|
static_assert(
|
|
std::is_floating_point<RealType>::value,
|
|
"Class-template absl::exponential_distribution<> must be parameterized "
|
|
"using a floating-point type.");
|
|
};
|
|
|
|
exponential_distribution() : exponential_distribution(1) {}
|
|
|
|
explicit exponential_distribution(result_type lambda) : param_(lambda) {}
|
|
|
|
explicit exponential_distribution(const param_type& p) : param_(p) {}
|
|
|
|
void reset() {}
|
|
|
|
// Generating functions
|
|
template <typename URBG>
|
|
result_type operator()(URBG& g) { // NOLINT(runtime/references)
|
|
return (*this)(g, param_);
|
|
}
|
|
|
|
template <typename URBG>
|
|
result_type operator()(URBG& g, // NOLINT(runtime/references)
|
|
const param_type& p);
|
|
|
|
param_type param() const { return param_; }
|
|
void param(const param_type& p) { param_ = p; }
|
|
|
|
result_type(min)() const { return 0; }
|
|
result_type(max)() const {
|
|
return std::numeric_limits<result_type>::infinity();
|
|
}
|
|
|
|
result_type lambda() const { return param_.lambda(); }
|
|
|
|
friend bool operator==(const exponential_distribution& a,
|
|
const exponential_distribution& b) {
|
|
return a.param_ == b.param_;
|
|
}
|
|
friend bool operator!=(const exponential_distribution& a,
|
|
const exponential_distribution& b) {
|
|
return a.param_ != b.param_;
|
|
}
|
|
|
|
private:
|
|
param_type param_;
|
|
random_internal::FastUniformBits<uint64_t> fast_u64_;
|
|
};
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Implementation details follow
|
|
// --------------------------------------------------------------------------
|
|
|
|
template <typename RealType>
|
|
template <typename URBG>
|
|
typename exponential_distribution<RealType>::result_type
|
|
exponential_distribution<RealType>::operator()(
|
|
URBG& g, // NOLINT(runtime/references)
|
|
const param_type& p) {
|
|
using random_internal::GenerateNegativeTag;
|
|
using random_internal::GenerateRealFromBits;
|
|
using real_type =
|
|
absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
|
|
|
|
const result_type u = GenerateRealFromBits<real_type, GenerateNegativeTag,
|
|
false>(fast_u64_(g)); // U(-1, 0)
|
|
|
|
// log1p(-x) is mathematically equivalent to log(1 - x) but has more
|
|
// accuracy for x near zero.
|
|
return p.neg_inv_lambda_ * std::log1p(u);
|
|
}
|
|
|
|
template <typename CharT, typename Traits, typename RealType>
|
|
std::basic_ostream<CharT, Traits>& operator<<(
|
|
std::basic_ostream<CharT, Traits>& os, // NOLINT(runtime/references)
|
|
const exponential_distribution<RealType>& x) {
|
|
auto saver = random_internal::make_ostream_state_saver(os);
|
|
os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
|
|
os << x.lambda();
|
|
return os;
|
|
}
|
|
|
|
template <typename CharT, typename Traits, typename RealType>
|
|
std::basic_istream<CharT, Traits>& operator>>(
|
|
std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references)
|
|
exponential_distribution<RealType>& x) { // NOLINT(runtime/references)
|
|
using result_type = typename exponential_distribution<RealType>::result_type;
|
|
using param_type = typename exponential_distribution<RealType>::param_type;
|
|
result_type lambda;
|
|
|
|
auto saver = random_internal::make_istream_state_saver(is);
|
|
lambda = random_internal::read_floating_point<result_type>(is);
|
|
if (!is.fail()) {
|
|
x.param(param_type(lambda));
|
|
}
|
|
return is;
|
|
}
|
|
|
|
} // namespace absl
|
|
|
|
#endif // ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
|