This is an archive of the discontinued LLVM Phabricator instance.

Differential D156931

[libc++] Granularize most cmath includes
Needs ReviewPublic

Authored by philnik on Aug 2 2023, 11:48 AM.

Details

Reviewers
None
Group Reviewers
Restricted Project

Diff Detail

Event Timeline

philnik created this revision.Aug 2 2023, 11:48 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 2 2023, 11:48 AM
philnik requested review of this revision.Aug 2 2023, 11:48 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 2 2023, 11:48 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B249853: Diff 546566.Aug 2 2023, 2:04 PM
ldionne added a parent revision: D155258: [libc++] Granulaize math.h and move the functions to std::__math.Aug 17 2023, 8:45 AM
ldionne added a subscriber: ldionne.Aug 17 2023, 8:50 AM

As discussed just now, I would like to understand the concrete benefit for doing this granularization. Usually, granularizing headers that are higher in the stack helps with disentangling include cycles. This is not the case here since <cmath> is basically its own little "submodule". Do we get any compile-time benefit when we disable transitive includes?

If we could e.g. run the test suite with transitive includes disabled and show that this change makes a difference, that would be some motivation to make this change. Otherwise, I must say I am skeptical of the benefit of splitting up a header that was as "simple" as this (I mean with few other dependencies).

Revision Contents

PathSize
libcxx/
include/
__chrono/
1 line
__compare/
23 lines
12 lines
__format/
8 lines
19 lines
__random/
9 lines
4 lines
7 lines
4 lines
4 lines
14 lines
6 lines
5 lines
3 lines
31 lines
4 lines
4 lines
2 lines
1 line
1 line
4 lines
4 lines
2 lines
4 lines
1 line
1 line
test/
libcxx/
transitive_includes/
10 lines
10 lines
std/
numerics/
rand/
rand.dist/
rand.dist.bern/
rand.dist.bern.bernoulli/
7 lines
7 lines
rand.dist.bern.bin/
7 lines
1 line
5 lines
rand.dist.bern.geo/
1 line
5 lines
rand.dist.bern.negbin/
5 lines
5 lines
rand.dist.norm/
rand.dist.norm.chisq/
7 lines
7 lines
rand.dist.norm.lognormal/
5 lines
5 lines
rand.dist.norm.normal/
7 lines
7 lines
rand.dist.norm.t/
5 lines
5 lines
rand.dist.pois/
rand.dist.pois.exp/
7 lines
7 lines
rand.dist.pois.extreme/
5 lines
5 lines
rand.dist.pois.gamma/
5 lines
5 lines
rand.dist.pois.poisson/
5 lines
rand.dist.pois.weibull/
7 lines
7 lines
rand.dist.samp/
rand.dist.samp.pconst/
9 lines
9 lines
rand.dist.samp.plinear/
9 lines
9 lines
rand.dist.uni/
rand.dist.uni.int/
1 line
7 lines
rand.dist.uni.real/
7 lines
7 lines
ranges/
range.factories/
range.repeat.view/
7 lines

Diff 546566

libcxx/include/__chrono/formatter.h

Show All 35 Lines
#include <__format/concepts.h> #include <__format/concepts.h>
#include <__format/format_error.h> #include <__format/format_error.h>
#include <__format/format_functions.h> #include <__format/format_functions.h>
#include <__format/format_parse_context.h> #include <__format/format_parse_context.h>
#include <__format/formatter.h> #include <__format/formatter.h>
#include <__format/parser_std_format_spec.h> #include <__format/parser_std_format_spec.h>
#include <__format/write_escaped.h> #include <__format/write_escaped.h>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <cmath>
#include <ctime> #include <ctime>
#include <sstream> #include <sstream>
#include <string_view> #include <string_view>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 778 Lines • Show Last 20 Lines

libcxx/include/__compare/strong_order.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_STRONG_ORDER #ifndef _LIBCPP___COMPARE_STRONG_ORDER
#define _LIBCPP___COMPARE_STRONG_ORDER #define _LIBCPP___COMPARE_STRONG_ORDER
#include <__bit/bit_cast.h> #include <__bit/bit_cast.h>
#include <__compare/compare_three_way.h> #include <__compare/compare_three_way.h>
#include <__compare/ordering.h> #include <__compare/ordering.h>
#include <__config> #include <__config>
#include <__math/exponential_functions.h>
#include <__math/traits.h>
#include <__type_traits/conditional.h> #include <__type_traits/conditional.h>
#include <__type_traits/decay.h> #include <__type_traits/decay.h>
#include <__type_traits/is_floating_point.h>
#include <__type_traits/is_same.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/priority_tag.h> #include <__utility/priority_tag.h>
#include <cmath>
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
Show All 34 Lines // NOLINTEND(libcpp-robust-against-adl)
__ry = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry; __ry = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
return (__rx <=> __ry); return (__rx <=> __ry);
} else if (__t < __u) { } else if (__t < __u) {
return strong_ordering::less; return strong_ordering::less;
} else if (__t > __u) { } else if (__t > __u) {
return strong_ordering::greater; return strong_ordering::greater;
} else if (__t == __u) { } else if (__t == __u) {
if constexpr (numeric_limits<_Dp>::radix == 2) { if constexpr (numeric_limits<_Dp>::radix == 2) {
return _VSTD::signbit(__u) <=> _VSTD::signbit(__t); return __math::signbit(__u) <=> __math::signbit(__t);
} else { } else {
// This is bullet 3 of the IEEE754 algorithm, relevant // This is bullet 3 of the IEEE754 algorithm, relevant
// only for decimal floating-point; // only for decimal floating-point;
// see https://stackoverflow.com/questions/69068075/ // see https://stackoverflow.com/questions/69068075/
if (__t == 0 || _VSTD::isinf(__t)) { if (__t == 0 || __math::isinf(__t)) {
return _VSTD::signbit(__u) <=> _VSTD::signbit(__t); return __math::signbit(__u) <=> __math::signbit(__t);
} else { } else {
int __texp, __uexp; int __texp, __uexp;
(void)_VSTD::frexp(__t, &__texp); (void)__math::frexp(__t, &__texp);
(void)_VSTD::frexp(__u, &__uexp); (void)__math::frexp(__u, &__uexp);
return (__t < 0) ? (__texp <=> __uexp) : (__uexp <=> __texp); return (__t < 0) ? (__texp <=> __uexp) : (__uexp <=> __texp);
} }
} }
} else { } else {
// They're unordered, so one of them must be a NAN. // They're unordered, so one of them must be a NAN.
// The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN. // The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
bool __t_is_nan = _VSTD::isnan(__t); bool __t_is_nan = __math::isnan(__t);
bool __u_is_nan = _VSTD::isnan(__u); bool __u_is_nan = __math::isnan(__u);
bool __t_is_negative = _VSTD::signbit(__t); bool __t_is_negative = __math::signbit(__t);
bool __u_is_negative = _VSTD::signbit(__u); bool __u_is_negative = __math::signbit(__u);
using _IntType = conditional_t< using _IntType = conditional_t<
sizeof(__t) == sizeof(int32_t), int32_t, conditional_t< sizeof(__t) == sizeof(int32_t), int32_t, conditional_t<
sizeof(__t) == sizeof(int64_t), int64_t, void> sizeof(__t) == sizeof(int64_t), int64_t, void>
>; >;
if constexpr (is_same_v<_IntType, void>) { if constexpr (is_same_v<_IntType, void>) {
static_assert(sizeof(_Dp) == 0, "std::strong_order is unimplemented for this floating-point type"); static_assert(sizeof(_Dp) == 0, "std::strong_order is unimplemented for this floating-point type");
} else if (__t_is_nan && __u_is_nan) { } else if (__t_is_nan && __u_is_nan) {
// Order by sign bit, then by "payload bits" (we'll just use bit_cast). // Order by sign bit, then by "payload bits" (we'll just use bit_cast).
Show All 40 Lines

libcxx/include/__compare/weak_order.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___COMPARE_WEAK_ORDER #ifndef _LIBCPP___COMPARE_WEAK_ORDER
#define _LIBCPP___COMPARE_WEAK_ORDER #define _LIBCPP___COMPARE_WEAK_ORDER
#include <__compare/compare_three_way.h> #include <__compare/compare_three_way.h>
#include <__compare/ordering.h> #include <__compare/ordering.h>
#include <__compare/strong_order.h> #include <__compare/strong_order.h>
#include <__config> #include <__config>
#include <__math/traits.h>
#include <__type_traits/decay.h> #include <__type_traits/decay.h>
#include <__type_traits/is_floating_point.h>
#include <__type_traits/is_same.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/priority_tag.h> #include <__utility/priority_tag.h>
#include <cmath>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
Show All 20 Lines // NOLINTEND(libcpp-robust-against-adl)
if (__po == partial_ordering::less) { if (__po == partial_ordering::less) {
return weak_ordering::less; return weak_ordering::less;
} else if (__po == partial_ordering::equivalent) { } else if (__po == partial_ordering::equivalent) {
return weak_ordering::equivalent; return weak_ordering::equivalent;
} else if (__po == partial_ordering::greater) { } else if (__po == partial_ordering::greater) {
return weak_ordering::greater; return weak_ordering::greater;
} else { } else {
// Otherwise, at least one of them is a NaN. // Otherwise, at least one of them is a NaN.
bool __t_is_nan = _VSTD::isnan(__t); bool __t_is_nan = __math::isnan(__t);
bool __u_is_nan = _VSTD::isnan(__u); bool __u_is_nan = __math::isnan(__u);
bool __t_is_negative = _VSTD::signbit(__t); bool __t_is_negative = __math::signbit(__t);
bool __u_is_negative = _VSTD::signbit(__u); bool __u_is_negative = __math::signbit(__u);
if (__t_is_nan && __u_is_nan) { if (__t_is_nan && __u_is_nan) {
return (__u_is_negative <=> __t_is_negative); return (__u_is_negative <=> __t_is_negative);
} else if (__t_is_nan) { } else if (__t_is_nan) {
return __t_is_negative ? weak_ordering::less : weak_ordering::greater; return __t_is_negative ? weak_ordering::less : weak_ordering::greater;
} else { } else {
return __u_is_negative ? weak_ordering::greater : weak_ordering::less; return __u_is_negative ? weak_ordering::greater : weak_ordering::less;
} }
} }
Show All 35 Lines

libcxx/include/__format/formatter_floating_point.h

Show All 23 Lines
#include <__config> #include <__config>
#include <__format/concepts.h> #include <__format/concepts.h>
#include <__format/format_parse_context.h> #include <__format/format_parse_context.h>
#include <__format/formatter.h> #include <__format/formatter.h>
#include <__format/formatter_integral.h> #include <__format/formatter_integral.h>
#include <__format/formatter_output.h> #include <__format/formatter_output.h>
#include <__format/parser_std_format_spec.h> #include <__format/parser_std_format_spec.h>
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__math/traits.h>
#include <__memory/allocator.h> #include <__memory/allocator.h>
#include <__system_error/errc.h> #include <__system_error/errc.h>
#include <__type_traits/conditional.h> #include <__type_traits/conditional.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/unreachable.h> #include <__utility/unreachable.h>
#include <cmath>
#include <cstddef> #include <cstddef>
#ifndef _LIBCPP_HAS_NO_LOCALIZATION #ifndef _LIBCPP_HAS_NO_LOCALIZATION
# include <locale> # include <locale>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
▲ Show 20 Lines • Show All 592 Lines • ▼ Show 20 Lines_LIBCPP_HIDE_FROM_ABI auto __write_using_trailing_zeros(
__out_it = __formatter::__copy(__exponent, __last, _VSTD::move(__out_it)); __out_it = __formatter::__copy(__exponent, __last, _VSTD::move(__out_it));
return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_); return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
} }
template <floating_point _Tp, class _CharT, class _FormatContext> template <floating_point _Tp, class _CharT, class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
__format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) { __format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) {
bool __negative = _VSTD::signbit(__value); bool __negative = __math::signbit(__value);
if (!_VSTD::isfinite(__value)) [[unlikely]] if (!__math::isfinite(__value)) [[unlikely]]
return __formatter::__format_floating_point_non_finite(__ctx.out(), __specs, __negative, _VSTD::isnan(__value)); return __formatter::__format_floating_point_non_finite(__ctx.out(), __specs, __negative, __math::isnan(__value));
// Depending on the std-format-spec string the sign and the value // Depending on the std-format-spec string the sign and the value
// might not be outputted together: // might not be outputted together:
// - zero-padding may insert additional '0' characters. // - zero-padding may insert additional '0' characters.
// Therefore the value is processed as a non negative value. // Therefore the value is processed as a non negative value.
// The function @ref __insert_sign will insert a '-' when the value was // The function @ref __insert_sign will insert a '-' when the value was
// negative. // negative.
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

libcxx/include/__hash_table

Show All 12 Lines
#include <__algorithm/max.h> #include <__algorithm/max.h>
#include <__algorithm/min.h> #include <__algorithm/min.h>
#include <__assert> #include <__assert>
#include <__bit/countl.h> #include <__bit/countl.h>
#include <__config> #include <__config>
#include <__functional/hash.h> #include <__functional/hash.h>
#include <__functional/invoke.h> #include <__functional/invoke.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__math/rounding_functions.h>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__memory/allocator_traits.h> #include <__memory/allocator_traits.h>
#include <__memory/compressed_pair.h> #include <__memory/compressed_pair.h>
#include <__memory/pointer_traits.h> #include <__memory/pointer_traits.h>
#include <__memory/swap_allocator.h> #include <__memory/swap_allocator.h>
#include <__memory/unique_ptr.h> #include <__memory/unique_ptr.h>
#include <__type_traits/can_extract_key.h> #include <__type_traits/can_extract_key.h>
#include <__type_traits/conditional.h> #include <__type_traits/conditional.h>
#include <__type_traits/is_const.h> #include <__type_traits/is_const.h>
#include <__type_traits/is_copy_constructible.h> #include <__type_traits/is_copy_constructible.h>
#include <__type_traits/is_nothrow_constructible.h> #include <__type_traits/is_nothrow_constructible.h>
#include <__type_traits/is_nothrow_copy_constructible.h> #include <__type_traits/is_nothrow_copy_constructible.h>
#include <__type_traits/is_nothrow_default_constructible.h> #include <__type_traits/is_nothrow_default_constructible.h>
#include <__type_traits/is_nothrow_move_assignable.h> #include <__type_traits/is_nothrow_move_assignable.h>
#include <__type_traits/is_nothrow_move_constructible.h> #include <__type_traits/is_nothrow_move_constructible.h>
#include <__type_traits/is_pointer.h> #include <__type_traits/is_pointer.h>
#include <__type_traits/is_reference.h> #include <__type_traits/is_reference.h>
#include <__type_traits/is_swappable.h> #include <__type_traits/is_swappable.h>
#include <__type_traits/remove_const.h> #include <__type_traits/remove_const.h>
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <cmath>
#include <cstring> #include <cstring>
#include <initializer_list> #include <initializer_list>
#include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 948 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER >= 17
_NodeHandle __node_handle_extract(const_iterator __it); _NodeHandle __node_handle_extract(const_iterator __it);
#endif #endif
_LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT; _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
_LIBCPP_INLINE_VISIBILITY void __rehash_unique(size_type __n) { __rehash<true>(__n); } _LIBCPP_INLINE_VISIBILITY void __rehash_unique(size_type __n) { __rehash<true>(__n); }
_LIBCPP_INLINE_VISIBILITY void __rehash_multi(size_type __n) { __rehash<false>(__n); } _LIBCPP_INLINE_VISIBILITY void __rehash_multi(size_type __n) { __rehash<false>(__n); }
_LIBCPP_INLINE_VISIBILITY void __reserve_unique(size_type __n) _LIBCPP_INLINE_VISIBILITY void __reserve_unique(size_type __n)
{ {
__rehash_unique(static_cast<size_type>(std::ceil(__n / max_load_factor()))); __rehash_unique(static_cast<size_type>(__math::ceil(__n / max_load_factor())));
} }
_LIBCPP_INLINE_VISIBILITY void __reserve_multi(size_type __n) _LIBCPP_INLINE_VISIBILITY void __reserve_multi(size_type __n)
{ {
__rehash_multi(static_cast<size_type>(std::ceil(__n / max_load_factor()))); __rehash_multi(static_cast<size_type>(__math::ceil(__n / max_load_factor())));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const _NOEXCEPT size_type bucket_count() const _NOEXCEPT
{ {
return __bucket_list_.get_deleter().size(); return __bucket_list_.get_deleter().size();
} }
▲ Show 20 Lines • Show All 606 Lines • ▼ Show 20 Lines if (__bc != 0)
key_eq()(__ndptr->__upcast()->__value_, __value)) key_eq()(__ndptr->__upcast()->__value_, __value))
return __ndptr; return __ndptr;
} }
} }
} }
if (size()+1 > __bc * max_load_factor() || __bc == 0) if (size()+1 > __bc * max_load_factor() || __bc == 0)
{ {
__rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc), __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
size_type(std::ceil(float(size() + 1) / max_load_factor())))); size_type(__math::ceil(float(size() + 1) / max_load_factor()))));
} }
return nullptr; return nullptr;
} }
// Insert the node __nd into the container by pushing it into the right bucket, // Insert the node __nd into the container by pushing it into the right bucket,
// and updating size(). Assumes that __nd->__hash is up-to-date, and that // and updating size(). Assumes that __nd->__hash is up-to-date, and that
// rehashing has already occurred and that no element with the same key exists // rehashing has already occurred and that no element with the same key exists
// in the map. // in the map.
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_prepare( __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_prepare(
size_t __cp_hash, value_type& __cp_val) size_t __cp_hash, value_type& __cp_val)
{ {
size_type __bc = bucket_count(); size_type __bc = bucket_count();
if (size()+1 > __bc * max_load_factor() || __bc == 0) if (size()+1 > __bc * max_load_factor() || __bc == 0)
{ {
__rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc), __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
size_type(std::ceil(float(size() + 1) / max_load_factor())))); size_type(__math::ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count(); __bc = bucket_count();
} }
size_t __chash = std::__constrain_hash(__cp_hash, __bc); size_t __chash = std::__constrain_hash(__cp_hash, __bc);
__next_pointer __pn = __bucket_list_[__chash]; __next_pointer __pn = __bucket_list_[__chash];
if (__pn != nullptr) if (__pn != nullptr)
{ {
for (bool __found = false; __pn->__next_ != nullptr && for (bool __found = false; __pn->__next_ != nullptr &&
std::__constrain_hash(__pn->__next_->__hash(), __bc) == __chash; std::__constrain_hash(__pn->__next_->__hash(), __bc) == __chash;
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
if (__p != end() && key_eq()(*__p, __cp->__value_)) if (__p != end() && key_eq()(*__p, __cp->__value_))
{ {
__next_pointer __np = __p.__node_; __next_pointer __np = __p.__node_;
__cp->__hash_ = __np->__hash(); __cp->__hash_ = __np->__hash();
size_type __bc = bucket_count(); size_type __bc = bucket_count();
if (size()+1 > __bc * max_load_factor() || __bc == 0) if (size()+1 > __bc * max_load_factor() || __bc == 0)
{ {
__rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc), __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
size_type(std::ceil(float(size() + 1) / max_load_factor())))); size_type(__math::ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count(); __bc = bucket_count();
} }
size_t __chash = std::__constrain_hash(__cp->__hash_, __bc); size_t __chash = std::__constrain_hash(__cp->__hash_, __bc);
__next_pointer __pp = __bucket_list_[__chash]; __next_pointer __pp = __bucket_list_[__chash];
while (__pp->__next_ != __np) while (__pp->__next_ != __np)
__pp = __pp->__next_; __pp = __pp->__next_;
__cp->__next_ = __np; __cp->__next_ = __np;
__pp->__next_ = static_cast<__next_pointer>(__cp); __pp->__next_ = static_cast<__next_pointer>(__cp);
Show All 32 Lines if (__bc != 0)
} }
} }
} }
{ {
__node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...); __node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...);
if (size()+1 > __bc * max_load_factor() || __bc == 0) if (size()+1 > __bc * max_load_factor() || __bc == 0)
{ {
__rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc), __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
size_type(std::ceil(float(size() + 1) / max_load_factor())))); size_type(__math::ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count(); __bc = bucket_count();
__chash = std::__constrain_hash(__hash, __bc); __chash = std::__constrain_hash(__hash, __bc);
} }
// insert_after __bucket_list_[__chash], or __first_node if bucket is null // insert_after __bucket_list_[__chash], or __first_node if bucket is null
__next_pointer __pn = __bucket_list_[__chash]; __next_pointer __pn = __bucket_list_[__chash];
if (__pn == nullptr) if (__pn == nullptr)
{ {
__pn = __p1_.first().__ptr(); __pn = __p1_.first().__ptr();
▲ Show 20 Lines • Show All 199 Lines • ▼ Show 20 Lines_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
size_type __bc = bucket_count(); size_type __bc = bucket_count();
if (__n > __bc) if (__n > __bc)
__do_rehash<_UniqueKeys>(__n); __do_rehash<_UniqueKeys>(__n);
else if (__n < __bc) else if (__n < __bc)
{ {
__n = _VSTD::max<size_type> __n = _VSTD::max<size_type>
( (
__n, __n,
std::__is_hash_power2(__bc) ? std::__next_hash_pow2(size_t(std::ceil(float(size()) / max_load_factor()))) : std::__is_hash_power2(__bc) ? std::__next_hash_pow2(size_t(__math::ceil(float(size()) / max_load_factor()))) :
std::__next_prime(size_t(std::ceil(float(size()) / max_load_factor()))) std::__next_prime(size_t(__math::ceil(float(size()) / max_load_factor())))
); );
if (__n < __bc) if (__n < __bc)
__do_rehash<_UniqueKeys>(__n); __do_rehash<_UniqueKeys>(__n);
} }
} }
template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <bool _UniqueKeys> template <bool _UniqueKeys>
▲ Show 20 Lines • Show All 407 Lines • Show Last 20 Lines

libcxx/include/__random/binomial_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
#define _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H #define _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/exponential_functions.h>
#include <__math/logarithms.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
template<class _IntType> template<class _IntType>
binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p) binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p)
: __t_(__t), __p_(__p) : __t_(__t), __p_(__p)
{ {
if (0 < __p_ && __p_ < 1) if (0 < __p_ && __p_ < 1)
{ {
__r0_ = static_cast<result_type>((__t_ + 1) * __p_); __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
__pr_ = _VSTD::exp(std::__libcpp_lgamma(__t_ + 1.) - __pr_ = __math::exp(std::__libcpp_lgamma(__t_ + 1.) -
std::__libcpp_lgamma(__r0_ + 1.) - std::__libcpp_lgamma(__r0_ + 1.) -
std::__libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) + std::__libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * __math::log(__p_) +
(__t_ - __r0_) * _VSTD::log(1 - __p_)); (__t_ - __r0_) * __math::log(1 - __p_));
__odds_ratio_ = __p_ / (1 - __p_); __odds_ratio_ = __p_ / (1 - __p_);
} }
} }
// Reference: Kemp, C.D. (1986). `A modal method for generating binomial // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
// variables', Commun. Statist. - Theor. Meth. 15(3), 805-813. // variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
template<class _IntType> template<class _IntType>
template<class _URNG> template<class _URNG>
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

libcxx/include/__random/cauchy_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
#define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H #define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/trigonometric_functions.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
template<class _URNG> template<class _URNG>
inline inline
_RealType _RealType
cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{ {
static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
uniform_real_distribution<result_type> __gen; uniform_real_distribution<result_type> __gen;
// purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g)); return __p.a() + __p.b() * __math::tan(3.1415926535897932384626433832795 * __gen(__g));
} }
template <class _CharT, class _Traits, class _RT> template <class _CharT, class _Traits, class _RT>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, operator<<(basic_ostream<_CharT, _Traits>& __os,
const cauchy_distribution<_RT>& __x) const cauchy_distribution<_RT>& __x)
{ {
__save_flags<_CharT, _Traits> __lx(__os); __save_flags<_CharT, _Traits> __lx(__os);
Show All 33 Lines

libcxx/include/__random/clamp_to_integral.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H #ifndef _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H
#define _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H #define _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H
#include <__config> #include <__config>
#include <cmath> #include <__math/rounding_functions.h>
#include <__type_traits/is_floating_point.h>
#include <__type_traits/is_integral.h>
#include <__type_traits/is_same.h>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
Show All 17 Lines
// clamping to the integral type's representable range. // clamping to the integral type's representable range.
// //
// The behavior is undefined if `__r` is NaN. // The behavior is undefined if `__r` is NaN.
template <class _IntT, class _RealT> template <class _IntT, class _RealT>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_IntT __clamp_to_integral(_RealT __r) _NOEXCEPT { _IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
using _Lim = numeric_limits<_IntT>; using _Lim = numeric_limits<_IntT>;
const _IntT __max_val = __max_representable_int_for_float<_IntT, _RealT>(); const _IntT __max_val = __max_representable_int_for_float<_IntT, _RealT>();
if (__r >= ::nextafter(static_cast<_RealT>(__max_val), INFINITY)) { if (__r >= __math::nextafter(static_cast<_RealT>(__max_val), numeric_limits<_RealT>::infinity())) {
return _Lim::max(); return _Lim::max();
} else if (__r <= _Lim::lowest()) { } else if (__r <= _Lim::lowest()) {
return _Lim::min(); return _Lim::min();
} }
return static_cast<_IntT>(__r); return static_cast<_IntT>(__r);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H #endif // _LIBCPP___RANDOM_CLAMP_TO_INTEGRAL_H

libcxx/include/__random/exponential_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
#define _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H #define _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/logarithms.h>
#include <__random/generate_canonical.h> #include <__random/generate_canonical.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
}; };
template <class _RealType> template <class _RealType>
template<class _URNG> template<class _URNG>
_RealType _RealType
exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{ {
static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
return -_VSTD::log return -__math::log
( (
result_type(1) - result_type(1) -
_VSTD::generate_canonical<result_type, _VSTD::generate_canonical<result_type,
numeric_limits<result_type>::digits>(__g) numeric_limits<result_type>::digits>(__g)
) )
/ __p.lambda(); / __p.lambda();
} }
Show All 35 Lines

libcxx/include/__random/extreme_value_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
#define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H #define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/logarithms.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
template<class _RealType> template<class _RealType>
template<class _URNG> template<class _URNG>
_RealType _RealType
extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{ {
static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
return __p.a() - __p.b() * return __p.a() - __p.b() *
_VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g))); __math::log(-__math::log(1-uniform_real_distribution<result_type>()(__g)));
} }
template <class _CharT, class _Traits, class _RT> template <class _CharT, class _Traits, class _RT>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, operator<<(basic_ostream<_CharT, _Traits>& __os,
const extreme_value_distribution<_RT>& __x) const extreme_value_distribution<_RT>& __x)
{ {
__save_flags<_CharT, _Traits> __lx(__os); __save_flags<_CharT, _Traits> __lx(__os);
Show All 33 Lines

libcxx/include/__random/gamma_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
#define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H #define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/exponential_functions.h>
#include <__math/logarithms.h>
#include <__math/roots.h>
#include <__random/exponential_distribution.h> #include <__random/exponential_distribution.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines else if (__a > 1)
const result_type __c = 3 * __a - result_type(0.75); const result_type __c = 3 * __a - result_type(0.75);
while (true) while (true)
{ {
const result_type __u = __gen(__g); const result_type __u = __gen(__g);
const result_type __v = __gen(__g); const result_type __v = __gen(__g);
const result_type __w = __u * (1 - __u); const result_type __w = __u * (1 - __u);
if (__w != 0) if (__w != 0)
{ {
const result_type __y = _VSTD::sqrt(__c / __w) * const result_type __y = __math::sqrt(__c / __w) *
(__u - result_type(0.5)); (__u - result_type(0.5));
__x = __b + __y; __x = __b + __y;
if (__x >= 0) if (__x >= 0)
{ {
const result_type __z = 64 * __w * __w * __w * __v * __v; const result_type __z = 64 * __w * __w * __w * __v * __v;
if (__z <= 1 - 2 * __y * __y / __x) if (__z <= 1 - 2 * __y * __y / __x)
break; break;
if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y)) if (__math::log(__z) <= 2 * (__b * __math::log(__x / __b) - __y))
break; break;
} }
} }
} }
} }
else // __a < 1 else // __a < 1
{ {
while (true) while (true)
{ {
const result_type __u = __gen(__g); const result_type __u = __gen(__g);
const result_type __es = __egen(__g); const result_type __es = __egen(__g);
if (__u <= 1 - __a) if (__u <= 1 - __a)
{ {
__x = _VSTD::pow(__u, 1 / __a); __x = __math::pow(__u, 1 / __a);
if (__x <= __es) if (__x <= __es)
break; break;
} }
else else
{ {
const result_type __e = -_VSTD::log((1-__u)/__a); const result_type __e = -__math::log((1-__u)/__a);
__x = _VSTD::pow(1 - __a + __a * __e, 1 / __a); __x = __math::pow(1 - __a + __a * __e, 1 / __a);
if (__x <= __e + __es) if (__x <= __e + __es)
break; break;
} }
} }
} }
return __x * __p.beta(); return __x * __p.beta();
} }
Show All 39 Lines

libcxx/include/__random/lognormal_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
#define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H #define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/exponential_functions.h>
#include <__random/normal_distribution.h> #include <__random/normal_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void reset() {__nd_.reset();} void reset() {__nd_.reset();}
// generating functions // generating functions
template<class _URNG> template<class _URNG>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g) result_type operator()(_URNG& __g)
{ {
return _VSTD::exp(__nd_(__g)); return __math::exp(__nd_(__g));
} }
template<class _URNG> template<class _URNG>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p) result_type operator()(_URNG& __g, const param_type& __p)
{ {
typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s()); typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
return _VSTD::exp(__nd_(__g, __pn)); return __math::exp(__nd_(__g, __pn));
} }
// property functions // property functions
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type m() const {return __nd_.mean();} result_type m() const {return __nd_.mean();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type s() const {return __nd_.stddev();} result_type s() const {return __nd_.stddev();}
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

libcxx/include/__random/normal_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
#define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H #define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/logarithms.h>
#include <__math/roots.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines else
result_type __v; result_type __v;
result_type __s; result_type __s;
do do
{ {
__u = __uni(__g); __u = __uni(__g);
__v = __uni(__g); __v = __uni(__g);
__s = __u * __u + __v * __v; __s = __u * __u + __v * __v;
} while (__s > 1 || __s == 0); } while (__s > 1 || __s == 0);
result_type __fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s); result_type __fp = __math::sqrt(-2 * __math::log(__s) / __s);
__v_ = __v * __fp; __v_ = __v * __fp;
__v_hot_ = true; __v_hot_ = true;
__up = __u * __fp; __up = __u * __fp;
} }
return __up * __p.stddev() + __p.mean(); return __up * __p.stddev() + __p.mean();
} }
template <class _CharT, class _Traits, class _RT> template <class _CharT, class _Traits, class _RT>
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/include/__random/piecewise_linear_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
#define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H #define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
#include <__algorithm/upper_bound.h> #include <__algorithm/upper_bound.h>
#include <__config> #include <__config>
#include <__math/roots.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <iosfwd> #include <iosfwd>
#include <numeric> #include <numeric>
#include <vector> #include <vector>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
▲ Show 20 Lines • Show All 279 Lines • ▼ Show 20 Linespiecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
const result_type __dk1 = __p.__densities_[__k+1]; const result_type __dk1 = __p.__densities_[__k+1];
const result_type __deltad = __dk1 - __dk; const result_type __deltad = __dk1 - __dk;
const result_type __bk = __p.__b_[__k]; const result_type __bk = __p.__b_[__k];
if (__deltad == 0) if (__deltad == 0)
return __u / __dk + __bk; return __u / __dk + __bk;
const result_type __bk1 = __p.__b_[__k+1]; const result_type __bk1 = __p.__b_[__k+1];
const result_type __deltab = __bk1 - __bk; const result_type __deltab = __bk1 - __bk;
return (__bk * __dk1 - __bk1 * __dk + return (__bk * __dk1 - __bk1 * __dk +
_VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / __math::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
__deltad; __deltad;
} }
template <class _CharT, class _Traits, class _RT> template <class _CharT, class _Traits, class _RT>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, operator<<(basic_ostream<_CharT, _Traits>& __os,
const piecewise_linear_distribution<_RT>& __x) const piecewise_linear_distribution<_RT>& __x)
{ {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/include/__random/poisson_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
#define _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H #define _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/exponential_functions.h>
#include <__math/logarithms.h>
#include <__math/roots.h>
#include <__math/rounding_functions.h>
#include <__math/traits.h>
#include <__random/clamp_to_integral.h> #include <__random/clamp_to_integral.h>
#include <__random/exponential_distribution.h> #include <__random/exponential_distribution.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/normal_distribution.h> #include <__random/normal_distribution.h>
#include <__random/uniform_real_distribution.h> #include <__random/uniform_real_distribution.h>
#include <cmath> #include <cstdlib>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines friend _LIBCPP_INLINE_VISIBILITY
{return !(__x == __y);} {return !(__x == __y);}
}; };
template<class _IntType> template<class _IntType>
poisson_distribution<_IntType>::param_type::param_type(double __mean) poisson_distribution<_IntType>::param_type::param_type(double __mean)
// According to the standard `inf` is a valid input, but it causes the // According to the standard `inf` is a valid input, but it causes the
// distribution to hang, so we replace it with the maximum representable // distribution to hang, so we replace it with the maximum representable
// mean. // mean.
: __mean_(isinf(__mean) ? numeric_limits<double>::max() : __mean) : __mean_(__math::isinf(__mean) ? numeric_limits<double>::max() : __mean)
{ {
if (__mean_ < 10) if (__mean_ < 10)
{ {
__s_ = 0; __s_ = 0;
__d_ = 0; __d_ = 0;
__l_ = _VSTD::exp(-__mean_); __l_ = __math::exp(-__mean_);
__omega_ = 0; __omega_ = 0;
__c3_ = 0; __c3_ = 0;
__c2_ = 0; __c2_ = 0;
__c1_ = 0; __c1_ = 0;
__c0_ = 0; __c0_ = 0;
__c_ = 0; __c_ = 0;
} }
else else
{ {
__s_ = _VSTD::sqrt(__mean_); __s_ = __math::sqrt(__mean_);
__d_ = 6 * __mean_ * __mean_; __d_ = 6 * __mean_ * __mean_;
__l_ = _VSTD::trunc(__mean_ - 1.1484); __l_ = __math::trunc(__mean_ - 1.1484);
__omega_ = .3989423 / __s_; __omega_ = .3989423 / __s_;
double __b1 = .4166667E-1 / __mean_; double __b1 = .4166667E-1 / __mean_;
double __b2 = .3 * __b1 * __b1; double __b2 = .3 * __b1 * __b1;
__c3_ = .1428571 * __b1 * __b2; __c3_ = .1428571 * __b1 * __b2;
__c2_ = __b2 - 15. * __c3_; __c2_ = __b2 - 15. * __c3_;
__c1_ = __b1 - 6. * __b2 + 45. * __c3_; __c1_ = __b1 - 6. * __b2 + 45. * __c3_;
__c0_ = 1. - __b1 + 3. * __b2 - 15. * __c3_; __c0_ = 1. - __b1 + 3. * __b2 - 15. * __c3_;
__c_ = .1069 / __mean_; __c_ = .1069 / __mean_;
Show All 16 Linespoisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
} }
else else
{ {
double __difmuk; double __difmuk;
double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng); double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
double __u; double __u;
if (__g > 0) if (__g > 0)
{ {
__tx = _VSTD::trunc(__g); __tx = __math::trunc(__g);
if (__tx >= __pr.__l_) if (__tx >= __pr.__l_)
return _VSTD::__clamp_to_integral<result_type>(__tx); return _VSTD::__clamp_to_integral<result_type>(__tx);
__difmuk = __pr.__mean_ - __tx; __difmuk = __pr.__mean_ - __tx;
__u = __urd(__urng); __u = __urd(__urng);
if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk) if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
return _VSTD::__clamp_to_integral<result_type>(__tx); return _VSTD::__clamp_to_integral<result_type>(__tx);
} }
exponential_distribution<double> __edist; exponential_distribution<double> __edist;
for (bool __using_exp_dist = false; true; __using_exp_dist = true) for (bool __using_exp_dist = false; true; __using_exp_dist = true)
{ {
double __e; double __e;
if (__using_exp_dist || __g <= 0) if (__using_exp_dist || __g <= 0)
{ {
double __t; double __t;
do do
{ {
__e = __edist(__urng); __e = __edist(__urng);
__u = __urd(__urng); __u = __urd(__urng);
__u += __u - 1; __u += __u - 1;
__t = 1.8 + (__u < 0 ? -__e : __e); __t = 1.8 + (__u < 0 ? -__e : __e);
} while (__t <= -.6744); } while (__t <= -.6744);
__tx = _VSTD::trunc(__pr.__mean_ + __pr.__s_ * __t); __tx = __math::trunc(__pr.__mean_ + __pr.__s_ * __t);
__difmuk = __pr.__mean_ - __tx; __difmuk = __pr.__mean_ - __tx;
__using_exp_dist = true; __using_exp_dist = true;
} }
double __px; double __px;
double __py; double __py;
if (__tx < 10 && __tx >= 0) if (__tx < 10 && __tx >= 0)
{ {
const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
40320, 362880}; 40320, 362880};
__px = -__pr.__mean_; __px = -__pr.__mean_;
__py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)]; __py = __math::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)];
} }
else else
{ {
double __del = .8333333E-1 / __tx; double __del = .8333333E-1 / __tx;
__del -= 4.8 * __del * __del * __del; __del -= 4.8 * __del * __del * __del;
double __v = __difmuk / __tx; double __v = __difmuk / __tx;
if (_VSTD::abs(__v) > 0.25) if (_VSTD::abs(__v) > 0.25)
__px = __tx * _VSTD::log(1 + __v) - __difmuk - __del; __px = __tx * __math::log(1 + __v) - __difmuk - __del;
else else
__px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) * __px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) *
__v + .1421878) * __v + -.1661269) * __v + .2000118) * __v + .1421878) * __v + -.1661269) * __v + .2000118) *
__v + -.2500068) * __v + .3333333) * __v + -.5) - __del; __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
__py = .3989423 / _VSTD::sqrt(__tx); __py = .3989423 / __math::sqrt(__tx);
} }
double __r = (0.5 - __difmuk) / __pr.__s_; double __r = (0.5 - __difmuk) / __pr.__s_;
double __r2 = __r * __r; double __r2 = __r * __r;
double __fx = -0.5 * __r2; double __fx = -0.5 * __r2;
double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) * double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
__r2 + __pr.__c1_) * __r2 + __pr.__c0_); __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
if (__using_exp_dist) if (__using_exp_dist)
{ {
if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) - if (__pr.__c_ * _VSTD::abs(__u) <= __py * __math::exp(__px + __e) -
__fy * _VSTD::exp(__fx + __e)) __fy * __math::exp(__fx + __e))
break; break;
} }
else else
{ {
if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx)) if (__fy - __u * __fy <= __py * __math::exp(__px - __fx))
break; break;
} }
} }
} }
return _VSTD::__clamp_to_integral<result_type>(__tx); return _VSTD::__clamp_to_integral<result_type>(__tx);
} }
template <class _CharT, class _Traits, class _IntType> template <class _CharT, class _Traits, class _IntType>
Show All 33 Lines

libcxx/include/__random/student_t_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
#define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H #define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/roots.h>
#include <__random/gamma_distribution.h> #include <__random/gamma_distribution.h>
#include <__random/is_valid.h> #include <__random/is_valid.h>
#include <__random/normal_distribution.h> #include <__random/normal_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
template <class _RealType> template <class _RealType>
template<class _URNG> template<class _URNG>
_RealType _RealType
student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{ {
static_assert(__libcpp_random_is_valid_urng<_URNG>::value, ""); static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
gamma_distribution<result_type> __gd(__p.n() * .5, 2); gamma_distribution<result_type> __gd(__p.n() * .5, 2);
return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g)); return __nd_(__g) * __math::sqrt(__p.n()/__gd(__g));
} }
template <class _CharT, class _Traits, class _RT> template <class _CharT, class _Traits, class _RT>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, operator<<(basic_ostream<_CharT, _Traits>& __os,
const student_t_distribution<_RT>& __x) const student_t_distribution<_RT>& __x)
{ {
__save_flags<_CharT, _Traits> __lx(__os); __save_flags<_CharT, _Traits> __lx(__os);
Show All 30 Lines

libcxx/include/__random/weibull_distribution.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H #ifndef _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
#define _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H #define _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
#include <__config> #include <__config>
#include <__math/exponential_functions.h>
#include <__random/exponential_distribution.h> #include <__random/exponential_distribution.h>
#include <cmath>
#include <iosfwd> #include <iosfwd>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines#endif
template<class _URNG> template<class _URNG>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g) result_type operator()(_URNG& __g)
{return (*this)(__g, __p_);} {return (*this)(__g, __p_);}
template<class _URNG> template<class _URNG>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p) result_type operator()(_URNG& __g, const param_type& __p)
{return __p.b() * {return __p.b() *
_VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());} __math::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
// property functions // property functions
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type a() const {return __p_.a();} result_type a() const {return __p_.a();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
result_type b() const {return __p_.b();} result_type b() const {return __p_.b();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

libcxx/include/charconv

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
#include <__charconv/to_chars.h> #include <__charconv/to_chars.h>
#include <__charconv/to_chars_base_10.h> #include <__charconv/to_chars_base_10.h>
#include <__charconv/to_chars_floating_point.h> #include <__charconv/to_chars_floating_point.h>
#include <__charconv/to_chars_integral.h> #include <__charconv/to_chars_integral.h>
#include <__charconv/to_chars_result.h> #include <__charconv/to_chars_result.h>
#include <__charconv/traits.h> #include <__charconv/traits.h>
#include <__config> #include <__config>
#include <__system_error/errc.h> #include <__system_error/errc.h>
#include <cmath> // for log2f
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath>
# include <concepts> # include <concepts>
# include <cstdlib> # include <cstdlib>
# include <cstring> # include <cstring>
# include <iosfwd> # include <iosfwd>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_CHARCONV #endif // _LIBCPP_CHARCONV

libcxx/include/chrono

Show First 20 Lines • Show All 806 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <bit> # include <bit>
# include <concepts> # include <concepts>
# include <cstring> # include <cstring>
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20
# include <charconv> # include <charconv>
# include <cmath>
#endif #endif
#endif // _LIBCPP_CHRONO #endif // _LIBCPP_CHRONO

libcxx/include/compare

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_COMPARE #endif // _LIBCPP_COMPARE

libcxx/include/ctgmath

Show All 13 Lines/*
ctgmath synopsis ctgmath synopsis
#include <ccomplex> #include <ccomplex>
#include <cmath> #include <cmath>
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
// standard-mandated includes
// [c.math] (C++14)
#include <ccomplex> #include <ccomplex>
#include <cmath> #include <cmath>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_CTGMATH #endif // _LIBCPP_CTGMATH

libcxx/include/format

Show First 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
#include <__format/range_formatter.h> #include <__format/range_formatter.h>
#include <__format/unicode.h> #include <__format/unicode.h>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath>
#endif
#endif // _LIBCPP_FORMAT #endif // _LIBCPP_FORMAT

libcxx/include/numeric

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Linestemplate<class T>
constexpr T* midpoint(T* a, T* b); // C++20 constexpr T* midpoint(T* a, T* b); // C++20
} // std } // std
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <cmath> // for isnormal
#include <version> #include <version>
#include <__numeric/accumulate.h> #include <__numeric/accumulate.h>
#include <__numeric/adjacent_difference.h> #include <__numeric/adjacent_difference.h>
#include <__numeric/exclusive_scan.h> #include <__numeric/exclusive_scan.h>
#include <__numeric/gcd_lcm.h> #include <__numeric/gcd_lcm.h>
#include <__numeric/inclusive_scan.h> #include <__numeric/inclusive_scan.h>
#include <__numeric/inner_product.h> #include <__numeric/inner_product.h>
#include <__numeric/iota.h> #include <__numeric/iota.h>
#include <__numeric/midpoint.h> #include <__numeric/midpoint.h>
#include <__numeric/partial_sum.h> #include <__numeric/partial_sum.h>
#include <__numeric/pstl_reduce.h> #include <__numeric/pstl_reduce.h>
#include <__numeric/pstl_transform_reduce.h> #include <__numeric/pstl_transform_reduce.h>
#include <__numeric/reduce.h> #include <__numeric/reduce.h>
#include <__numeric/transform_exclusive_scan.h> #include <__numeric/transform_exclusive_scan.h>
#include <__numeric/transform_inclusive_scan.h> #include <__numeric/transform_inclusive_scan.h>
#include <__numeric/transform_reduce.h> #include <__numeric/transform_reduce.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath>
# include <concepts> # include <concepts>
# include <functional> # include <functional>
# include <iterator> # include <iterator>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_NUMERIC #endif // _LIBCPP_NUMERIC

libcxx/include/print

Show First 20 Lines • Show All 380 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(string_view __fmt, format_args __args) { _LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(string_view __fmt, format_args __args) {
std::vprint_nonunicode(stdout, __fmt, __args); std::vprint_nonunicode(stdout, __fmt, __args);
} }
#endif // _LIBCPP_STD_VER >= 23 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath>
#endif
#endif // _LIBCPP_PRINT #endif // _LIBCPP_PRINT

libcxx/include/unordered_map

Show First 20 Lines • Show All 2,790 Lines • ▼ Show 20 Linesusing unordered_multimap _LIBCPP_AVAILABILITY_PMR =
std::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>; std::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <algorithm> # include <algorithm>
# include <bit> # include <bit>
# include <cmath>
# include <concepts> # include <concepts>
# include <cstdlib> # include <cstdlib>
# include <iterator> # include <iterator>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_UNORDERED_MAP #endif // _LIBCPP_UNORDERED_MAP

libcxx/include/unordered_set

Show First 20 Lines • Show All 1,966 Lines • ▼ Show 20 Lines
template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>> template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
using unordered_multiset _LIBCPP_AVAILABILITY_PMR = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>; using unordered_multiset _LIBCPP_AVAILABILITY_PMR = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath>
# include <concepts> # include <concepts>
# include <cstdlib> # include <cstdlib>
# include <functional> # include <functional>
# include <iterator> # include <iterator>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_UNORDERED_SET #endif // _LIBCPP_UNORDERED_SET

libcxx/test/libcxx/transitive_includes/cxx23.csv

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
bitset limits bitset limits
bitset new bitset new
bitset stdexcept bitset stdexcept
bitset string bitset string
bitset string_view bitset string_view
bitset version bitset version
ccomplex complex ccomplex complex
charconv cerrno charconv cerrno
charconv cmath
charconv cstddef charconv cstddef
charconv cstdint charconv cstdint
charconv initializer_list charconv initializer_list
charconv limits charconv limits
charconv new charconv new
chrono array chrono array
chrono cmath
chrono compare chrono compare
chrono cstddef chrono cstddef
chrono cstdint chrono cstdint
chrono ctime chrono ctime
chrono initializer_list chrono initializer_list
chrono limits chrono limits
chrono locale chrono locale
chrono new chrono new
Show All 20 Lines
codecvt iosfwd codecvt iosfwd
codecvt limits codecvt limits
codecvt mutex codecvt mutex
codecvt new codecvt new
codecvt stdexcept codecvt stdexcept
codecvt string codecvt string
codecvt typeinfo codecvt typeinfo
codecvt version codecvt version
compare cmath
compare cstddef compare cstddef
compare cstdint compare cstdint
compare limits compare limits
compare version compare version
complex cmath complex cmath
complex iosfwd complex iosfwd
complex sstream complex sstream
complex stdexcept complex stdexcept
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
filesystem limits filesystem limits
filesystem locale filesystem locale
filesystem new filesystem new
filesystem ratio filesystem ratio
filesystem string filesystem string
filesystem string_view filesystem string_view
filesystem version filesystem version
format array format array
format cmath
format cstddef format cstddef
format cstdint format cstdint
format initializer_list format initializer_list
format limits format limits
format locale format locale
format new format new
format optional format optional
format queue format queue
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines
mutex tuple mutex tuple
mutex typeinfo mutex typeinfo
mutex version mutex version
new cstddef new cstddef
new cstdlib new cstdlib
new version new version
numbers version numbers version
numeric climits numeric climits
numeric cmath
numeric cstddef numeric cstddef
numeric cstdint numeric cstdint
numeric cstring numeric cstring
numeric ctime numeric ctime
numeric execution numeric execution
numeric initializer_list numeric initializer_list
numeric limits numeric limits
numeric new numeric new
Show All 21 Lines
ostream new ostream new
ostream stdexcept ostream stdexcept
ostream streambuf ostream streambuf
ostream string ostream string
ostream typeinfo ostream typeinfo
ostream version ostream version
print array print array
print cerrno print cerrno
print cmath
print cstddef print cstddef
print cstdint print cstdint
print cstdio print cstdio
print initializer_list print initializer_list
print limits print limits
print locale print locale
print new print new
print optional print optional
print stdexcept print stdexcept
print string print string
print string_view print string_view
print tuple print tuple
print version print version
queue compare queue compare
queue cstddef queue cstddef
queue cstdint queue cstdint
queue deque queue deque
queue initializer_list queue initializer_list
queue limits queue limits
queue new queue new
queue vector queue vector
queue version queue version
random cmath
random cstddef random cstddef
random cstdint random cstdint
random cstdlib
random initializer_list random initializer_list
random iosfwd random iosfwd
random limits random limits
random numeric random numeric
random string random string
random vector random vector
random version random version
ranges compare ranges compare
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
type_traits cstddef type_traits cstddef
type_traits cstdint type_traits cstdint
type_traits version type_traits version
typeindex compare typeindex compare
typeindex typeinfo typeindex typeinfo
typeindex version typeindex version
typeinfo cstddef typeinfo cstddef
typeinfo cstdint typeinfo cstdint
unordered_map cmath
unordered_map compare unordered_map compare
unordered_map cstddef unordered_map cstddef
unordered_map cstdint unordered_map cstdint
unordered_map cstring unordered_map cstring
unordered_map initializer_list unordered_map initializer_list
unordered_map limits unordered_map limits
unordered_map new unordered_map new
unordered_map optional unordered_map optional
unordered_map stdexcept unordered_map stdexcept
unordered_map tuple unordered_map tuple
unordered_map version unordered_map version
unordered_set cmath
unordered_set compare unordered_set compare
unordered_set cstddef unordered_set cstddef
unordered_set cstdint unordered_set cstdint
unordered_set cstring unordered_set cstring
unordered_set initializer_list unordered_set initializer_list
unordered_set limits unordered_set limits
unordered_set new unordered_set new
unordered_set optional unordered_set optional
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/libcxx/transitive_includes/cxx26.csv

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
bitset limits bitset limits
bitset new bitset new
bitset stdexcept bitset stdexcept
bitset string bitset string
bitset string_view bitset string_view
bitset version bitset version
ccomplex complex ccomplex complex
charconv cerrno charconv cerrno
charconv cmath
charconv cstddef charconv cstddef
charconv cstdint charconv cstdint
charconv initializer_list charconv initializer_list
charconv limits charconv limits
charconv new charconv new
chrono array chrono array
chrono cmath
chrono compare chrono compare
chrono cstddef chrono cstddef
chrono cstdint chrono cstdint
chrono ctime chrono ctime
chrono initializer_list chrono initializer_list
chrono limits chrono limits
chrono locale chrono locale
chrono new chrono new
Show All 20 Lines
codecvt iosfwd codecvt iosfwd
codecvt limits codecvt limits
codecvt mutex codecvt mutex
codecvt new codecvt new
codecvt stdexcept codecvt stdexcept
codecvt string codecvt string
codecvt typeinfo codecvt typeinfo
codecvt version codecvt version
compare cmath
compare cstddef compare cstddef
compare cstdint compare cstdint
compare limits compare limits
compare version compare version
complex cmath complex cmath
complex iosfwd complex iosfwd
complex sstream complex sstream
complex stdexcept complex stdexcept
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
filesystem limits filesystem limits
filesystem locale filesystem locale
filesystem new filesystem new
filesystem ratio filesystem ratio
filesystem string filesystem string
filesystem string_view filesystem string_view
filesystem version filesystem version
format array format array
format cmath
format cstddef format cstddef
format cstdint format cstdint
format initializer_list format initializer_list
format limits format limits
format locale format locale
format new format new
format optional format optional
format queue format queue
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines
mutex tuple mutex tuple
mutex typeinfo mutex typeinfo
mutex version mutex version
new cstddef new cstddef
new cstdlib new cstdlib
new version new version
numbers version numbers version
numeric climits numeric climits
numeric cmath
numeric cstddef numeric cstddef
numeric cstdint numeric cstdint
numeric cstring numeric cstring
numeric ctime numeric ctime
numeric execution numeric execution
numeric initializer_list numeric initializer_list
numeric limits numeric limits
numeric new numeric new
Show All 21 Lines
ostream new ostream new
ostream stdexcept ostream stdexcept
ostream streambuf ostream streambuf
ostream string ostream string
ostream typeinfo ostream typeinfo
ostream version ostream version
print array print array
print cerrno print cerrno
print cmath
print cstddef print cstddef
print cstdint print cstdint
print cstdio print cstdio
print initializer_list print initializer_list
print limits print limits
print locale print locale
print new print new
print optional print optional
print stdexcept print stdexcept
print string print string
print string_view print string_view
print tuple print tuple
print version print version
queue compare queue compare
queue cstddef queue cstddef
queue cstdint queue cstdint
queue deque queue deque
queue initializer_list queue initializer_list
queue limits queue limits
queue new queue new
queue vector queue vector
queue version queue version
random cmath
random cstddef random cstddef
random cstdint random cstdint
random cstdlib
random initializer_list random initializer_list
random iosfwd random iosfwd
random limits random limits
random numeric random numeric
random string random string
random vector random vector
random version random version
ranges compare ranges compare
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines
type_traits cstddef type_traits cstddef
type_traits cstdint type_traits cstdint
type_traits version type_traits version
typeindex compare typeindex compare
typeindex typeinfo typeindex typeinfo
typeindex version typeindex version
typeinfo cstddef typeinfo cstddef
typeinfo cstdint typeinfo cstdint
unordered_map cmath
unordered_map compare unordered_map compare
unordered_map cstddef unordered_map cstddef
unordered_map cstdint unordered_map cstdint
unordered_map cstring unordered_map cstring
unordered_map initializer_list unordered_map initializer_list
unordered_map limits unordered_map limits
unordered_map new unordered_map new
unordered_map optional unordered_map optional
unordered_map stdexcept unordered_map stdexcept
unordered_map tuple unordered_map tuple
unordered_map version unordered_map version
unordered_set cmath
unordered_set compare unordered_set compare
unordered_set cstddef unordered_set cstddef
unordered_set cstdint unordered_set cstdint
unordered_set cstring unordered_set cstring
unordered_set initializer_list unordered_set initializer_list
unordered_set limits unordered_set limits
unordered_set new unordered_set new
unordered_set optional unordered_set optional
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bernoulli/eval.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// class bernoulli_distribution // class bernoulli_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <numeric>
#include <vector>
#include <cassert> #include <cassert>
#include <cmath>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// class bernoulli_distribution // class bernoulli_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <numeric>
#include <vector>
#include <cassert> #include <cassert>
#include <cmath>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.PR44847.pass.cpp

Show All 12 Lines
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
// Test the fix for https://llvm.org/PR44847. // Test the fix for https://llvm.org/PR44847.
// Serializing/deserializing the state of the RNG requires iostreams // Serializing/deserializing the state of the RNG requires iostreams
// UNSUPPORTED: no-localization // UNSUPPORTED: no-localization
#include <random>
#include <numeric>
#include <vector>
#include <cassert> #include <cassert>
#include <cmath>
#include <numeric>
#include <random>
#include <sstream> #include <sstream>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) { int main(int, char**) {
typedef std::binomial_distribution<> D; typedef std::binomial_distribution<> D;
typedef std::mt19937 G; typedef std::mt19937 G;
G g; G g;
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp

Show All 10 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class binomial_distribution // class binomial_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <cassert> #include <cassert>
#include <cmath>
#include <cstdint> #include <cstdint>
#include <numeric> #include <numeric>
#include <random> #include <random>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 515 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class binomial_distribution // class binomial_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random> #include <cassert>
#include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector> #include <vector>
#include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp

Show All 10 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class geometric_distribution // class geometric_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <cassert> #include <cassert>
#include <cmath>
#include <cstdint> #include <cstdint>
#include <numeric> #include <numeric>
#include <random> #include <random>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
▲ Show 20 Lines • Show All 301 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class geometric_distribution // class geometric_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random> #include <cassert>
#include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector> #include <vector>
#include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class negative_binomial_distribution // class negative_binomial_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random> #include <cassert>
#include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector> #include <vector>
#include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
T sqr(T x) { T sqr(T x) {
return x * x; return x * x;
} }
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class negative_binomial_distribution // class negative_binomial_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random> #include <cassert>
#include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector> #include <vector>
#include <cassert>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.chisq/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class chi_squared_distribution // class chi_squared_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.chisq/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class chi_squared_distribution // class chi_squared_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class lognormal_distribution // class lognormal_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class lognormal_distribution // class lognormal_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.normal/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class normal_distribution // class normal_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.normal/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class normal_distribution // class normal_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class student_t_distribution // class student_t_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class student_t_distribution // class student_t_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.exp/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class exponential_distribution // class exponential_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.exp/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class exponential_distribution // class exponential_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class extreme_value_distribution // class extreme_value_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class extreme_value_distribution // class extreme_value_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class gamma_distribution // class gamma_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class gamma_distribution // class gamma_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class IntType = int> // template<class IntType = int>
// class poisson_distribution // class poisson_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric> #include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.weibull/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class weibull_distribution // class weibull_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.weibull/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class weibull_distribution // class weibull_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class piecewise_constant_distribution // class piecewise_constant_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <vector>
#include <iterator>
#include <numeric>
#include <algorithm> // for sort #include <algorithm> // for sort
#include <cassert> #include <cassert>
#include <cmath>
#include <iterator>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 712 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class piecewise_constant_distribution // class piecewise_constant_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <algorithm> #include <algorithm>
#include <vector>
#include <iterator>
#include <numeric>
#include <cassert> #include <cassert>
#include <cmath>
#include <cstddef> #include <cstddef>
#include <iterator>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class piecewise_linear_distribution // class piecewise_linear_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <algorithm> #include <algorithm>
#include <vector>
#include <iterator>
#include <numeric>
#include <cassert> #include <cassert>
#include <cmath>
#include <iterator>
#include <limits> #include <limits>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 335 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class piecewise_linear_distribution // class piecewise_linear_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <vector>
#include <iterator>
#include <numeric>
#include <algorithm> // for sort #include <algorithm> // for sort
#include <cassert> #include <cassert>
#include <cmath>
#include <iterator>
#include <limits> #include <limits>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

Show All 11 Lines
// template<class _IntType = int> // template<class _IntType = int>
// class uniform_int_distribution // class uniform_int_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <cassert> #include <cassert>
#include <climits> #include <climits>
#include <cmath>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <limits> #include <limits>
#include <numeric> #include <numeric>
#include <random> #include <random>
#include <vector> #include <vector>
#include "test_macros.h" #include "test_macros.h"
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class _IntType = int> // template<class _IntType = int>
// class uniform_int_distribution // class uniform_int_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp

Show All 9 Lines
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class uniform_real_distribution // class uniform_real_distribution
// template<class _URNG> result_type operator()(_URNG& g); // template<class _URNG> result_type operator()(_URNG& g);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 448 Lines • Show Last 20 Lines

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <random> // <random>
// template<class RealType = double> // template<class RealType = double>
// class uniform_real_distribution // class uniform_real_distribution
// template<class _URNG> result_type operator()(_URNG& g, const param_type& parm); // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
#include <random>
#include <cassert> #include <cassert>
#include <vector> #include <cmath>
#include <numeric>
#include <cstddef> #include <cstddef>
#include <numeric>
#include <random>
#include <vector>
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
inline inline
T T
sqr(T x) sqr(T x)
{ {
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

libcxx/test/std/ranges/range.factories/range.repeat.view/size.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>); // constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
#include <ranges>
#include <numeric>
#include <concepts>
#include <cassert> #include <cassert>
#include <cmath>
#include <concepts>
#include <iterator> #include <iterator>
#include <numeric>
#include <ranges>
template <class T> template <class T>
concept has_size = requires(T&& view) { concept has_size = requires(T&& view) {
{ std::forward<T>(view).size() }; { std::forward<T>(view).size() };
}; };
static_assert(has_size<std::ranges::repeat_view<int, int>>); static_assert(has_size<std::ranges::repeat_view<int, int>>);
static_assert(!has_size<std::ranges::repeat_view<int>>); static_assert(!has_size<std::ranges::repeat_view<int>>);
Show All 22 Lines