[libc++][random] Removes transitive includes.

[Mordante]

Summary

It seems these includes are still provided by the sub headers, so it only
removes the duplicates.

There is no change in the list of includes, but the change affects the
modular build. By not having the includes in the top-level header the
module map has changed. This uncovers missing includes in the tests
and missing exports in the module map. This causes the huge amount of
changes in the patch.

[Mordante]

Fixes CI.

[Mordante]

Fixed modular build.

[EricWF]

Who is asking for these changes?

It's gunna break a lot of code, so we better have a rock solid, user-provided, justification for doing it.

[Mordante]

In D133252#3771962, @EricWF wrote:

Who is asking for these changes?

It's gunna break a lot of code, so we better have a rock solid, user-provided, justification for doing it.

Thanks for your concern.

There was no request, but a set of TODOs I cleaned up.

I want to discuss this with @ldionne since this change is special and not in a positive way.
Before and after the change exactly the same set of headers is included, therefore I marked the change NFC originally.
But not including them in random itself breaks the modular build.

Therefore I'm not convinced we should do this, but at least the test changes are an improvement and if we don't do it we need to remove these TODOs in random and add a warning instead.

[ldionne]

This change is a natural step in our ongoing effort to clean up incidental transitive includes. It just happened to surface the fact that our modulemap is written in an extremely lazy way (by using export *), which leads to our headers sometimes providing stuff implicitly when they shouldn't.

To be clear:

• I don't think this will break any more code than the other incidental-transitive-includes removals we've been doing (and which are guarded behind the standard version for now). Specifically, this one is a NFC for users that don't build with modules enabled, and it is a potential breaking change for users that build with -fmodules -std=c++23. I think it's reasonable to expect that those users can fix their includes, that's likely one of the reason they are using modules in the first place.
• Just to reiterate the motivation for this whole effort, removing transitive includes is necessary to implement some C++ features (otherwise we run into circular dependencies), and it also leads to shorter compilation times as @philnik measured.

IMO what we should do to tackle this issue once and for all is to fix our modulemap so that each header properly exports what it should be exporting, and nothing more. However, I think that is likely a ton of work, it's not fun work, and it's not clear that the ROI is that great given C++20 modules, so perhaps we should not actually do it, and only fix our modulemap as issues come up.

[philnik]

In D133252#3772246, @ldionne wrote:

This change is a natural step in our ongoing effort to clean up incidental transitive includes. It just happened to surface the fact that our modulemap is written in an extremely lazy way (by using export *), which leads to our headers sometimes providing stuff implicitly when they shouldn't.

To be clear:

• I don't think this will break any more code than the other incidental-transitive-includes removals we've been doing (and which are guarded behind the standard version for now). Specifically, this one is a NFC for users that don't build with modules enabled, and it is a potential breaking change for users that build with -fmodules -std=c++23. I think it's reasonable to expect that those users can fix their includes, that's likely one of the reason they are using modules in the first place.
• Just to reiterate the motivation for this whole effort, removing transitive includes is necessary to implement some C++ features (otherwise we run into circular dependencies), and it also leads to shorter compilation times as @philnik measured.

IMO what we should do to tackle this issue once and for all is to fix our modulemap so that each header properly exports what it should be exporting, and nothing more. However, I think that is likely a ton of work, it's not fun work, and it's not clear that the ROI is that great given C++20 modules, so perhaps we should not actually do it, and only fix our modulemap as issues come up.

The modulemap works actually pretty well with the granularized includes. With the current style everything defined inside a header in __public_header/ gets re-exported and anything else doesn't. So IMO we should just continue with granularizing all the headers instead of making the modulemap super complex.

libcxx/include/module.modulemap.in

943

Why do you have to re-export vector?

[Mordante]

libcxx/include/module.modulemap.in

943

A function in this header returns a vector. So it needs to be exported.
(Before it was exported by the export *.)

libcxx/docs/ReleaseNotes.rst

 Deprecations and Removals
 -------------------------
 - Several incidental transitive includes have been removed from libc++. Those
   includes are removed based on the language version used. Incidental transitive
   inclusions of the following headers have been removed:
 
   - C++20: ``chrono``
   - C++2b: ``algorithm``, ``array``, ``atomic``, ``bit``, ``chrono``,
-    ``climits``, ``cmath``, ``compare``, ``concepts``, ``cstdarg``, ``cstdlib``,
-    ``cstring``, ``ctime``, ``exception``, ``functional``,
-    ``initializer_list``, ``iosfwd``, ``iterator``, ``memory``, ``new``,
-    ``optional``, ``ratio``, ``stdexcept``, ``tuple``, ``typeinfo``,
-    ``unordered_map``, ``utility``, ``variant``, ``vector``.
+    ``climits``, ``cmath``, ``compare``, ``concepts``, ``cstdarg`, ``cstddef``,
+    ``cstdint``, ``cstdlib``, ``cstring``, ``ctime``, ``exception``,
+    ``functional``, ``initializer_list``, ``iosfwd``, ``iterator``, ``limits``,
+    ``memory``, ``new``, ``numeric``, ``optional``, ``ratio``, ``stdexcept``,
+    ``string``, ``tuple``, ``type_traits``, ``typeinfo``, ``unordered_map``,
+    ``utility``, ``variant``, ``vector``.
 
   Users can also remove all incidental transitive includes by defining
   ``_LIBCPP_REMOVE_TRANSITIVE_INCLUDES`` regardless of the language version
   in use. Note that in the future, libc++ reserves the right to remove
   incidental transitive includes more aggressively, in particular regardless
   of the language version in use.
 
 

libcxx/include/module.modulemap.in

module random {
     module __random {
       module bernoulli_distribution          { private header "__random/bernoulli_distribution.h" }
       module binomial_distribution           { private header "__random/binomial_distribution.h" }
       module cauchy_distribution             { private header "__random/cauchy_distribution.h" }
       module chi_squared_distribution        { private header "__random/chi_squared_distribution.h" }
       module clamp_to_integral               { private header "__random/clamp_to_integral.h" }
       module default_random_engine           { private header "__random/default_random_engine.h" }
       module discard_block_engine            { private header "__random/discard_block_engine.h" }
-      module discrete_distribution           { private header "__random/discrete_distribution.h" }
+      module discrete_distribution {
+        private header "__random/discrete_distribution.h"
+        export vector
+      }
       module exponential_distribution        { private header "__random/exponential_distribution.h" }
       module extreme_value_distribution      { private header "__random/extreme_value_distribution.h" }
       module fisher_f_distribution           { private header "__random/fisher_f_distribution.h" }
       module gamma_distribution              { private header "__random/gamma_distribution.h" }
       module generate_canonical              { private header "__random/generate_canonical.h" }
       module geometric_distribution          { private header "__random/geometric_distribution.h" }
       module independent_bits_engine         { private header "__random/independent_bits_engine.h" }
       module is_seed_sequence                { private header "__random/is_seed_sequence.h" }
       module is_valid                        { private header "__random/is_valid.h" }
       module knuth_b                         { private header "__random/knuth_b.h" }
       module linear_congruential_engine      { private header "__random/linear_congruential_engine.h" }
       module log2                            { private header "__random/log2.h" }
       module lognormal_distribution          { private header "__random/lognormal_distribution.h" }
       module mersenne_twister_engine         { private header "__random/mersenne_twister_engine.h" }
       module negative_binomial_distribution  { private header "__random/negative_binomial_distribution.h" }
       module normal_distribution             { private header "__random/normal_distribution.h" }
-      module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" }
-      module piecewise_linear_distribution   { private header "__random/piecewise_linear_distribution.h" }
+      module piecewise_constant_distribution {
+        private header "__random/piecewise_constant_distribution.h"
+        export vector
+      }
+      module piecewise_linear_distribution {
+        private header "__random/piecewise_linear_distribution.h"
+        export vector
+      }
       module poisson_distribution            { private header "__random/poisson_distribution.h" }
       module random_device                   { private header "__random/random_device.h" }
       module ranlux                          { private header "__random/ranlux.h" }
       module seed_seq                        { private header "__random/seed_seq.h" }
       module shuffle_order_engine            { private header "__random/shuffle_order_engine.h" }
       module student_t_distribution          { private header "__random/student_t_distribution.h" }
       module subtract_with_carry_engine      { private header "__random/subtract_with_carry_engine.h" }
       module uniform_int_distribution        { private header "__random/uniform_int_distribution.h" }

libcxx/include/random

 #include <__random/uniform_random_bit_generator.h>
 #include <__random/uniform_real_distribution.h>
 #include <__random/weibull_distribution.h>
 #include <version>
 
 // standard-mandated includes
 #include <initializer_list>
 
-#include <cmath>       // for backward compatibility; TODO remove it
-#include <cstddef>     // for backward compatibility; TODO remove it
-#include <cstdint>     // for backward compatibility; TODO remove it
-#include <iosfwd>      // for backward compatibility; TODO remove it
-#include <limits>      // for backward compatibility; TODO remove it
-#include <numeric>     // for backward compatibility; TODO remove it
-#include <string>      // for backward compatibility; TODO remove it
-#include <type_traits> // for backward compatibility; TODO remove it
-#include <vector>      // for backward compatibility; TODO remove it
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
+#  include <cmath>
+#  include <cstddef>
+#  include <cstdint>
+#  include <iosfwd>
+#  include <limits>
+#  include <numeric>
+#  include <string>
+#  include <type_traits>
+#  include <vector>
 #endif
 
 #endif // _LIBCPP_RANDOM

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_engine_move.pass.cpp

 
 // template<class Engine, size_t p, size_t r>
 // class discard_block_engine
 
 // explicit discard_block_engine(const Engine& e);
 
 #include <random>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::ranlux24_base Engine;
         typedef std::ranlux24 Adaptor;
         Engine e;
         Engine e0 = e;
         Adaptor a(std::move(e0));
         assert(a.base() == e);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_engine_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t w, class UIntType>
 // class independent_bits_engine
 
 // explicit independent_bits_engine(const Engine& e);
 
 #include <random>
+
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::mt19937 Engine;
         typedef std::independent_bits_engine<Engine, 24, unsigned> Adaptor;
         Engine e;
         Engine e0 = e;
         Adaptor a(std::move(e0));
         assert(a.base() == e);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t k>
 // class shuffle_order_engine
 
 // explicit shuffle_order_engine(const Engine& e);
 
 #include <random>
+
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::minstd_rand0 Engine;
         typedef std::knuth_b Adaptor;

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class geometric_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d(.25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class negative_binomial_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d(4, .25);
         assert(d.max() == std::numeric_limits<int>::max());
     }
 
   return 0;
 }

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

 // <random>
 
 // template<class RealType = double>
 // class cauchy_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 #include <vector>
 #include <algorithm>
 
 #include "test_macros.h"
 
 double
 f(double x, double a, double b)
 {

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

 // <random>
 
 // template<class RealType = double>
 // class cauchy_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 #include <vector>
 #include <algorithm>
 
 #include "test_macros.h"
 
 double
 f(double x, double a, double b)
 {

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.cauchy/max.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class cauchy_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.cauchy/min.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class cauchy_distribution
 
 // result_type min() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class chi_squared_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
         D d(5);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.norm/rand.dist.norm.f/max.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class fisher_f_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class lognormal_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class normal_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class normal_distribution
 
 // result_type min() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class student_t_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
         D d(5);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class student_t_distribution
 
 // result_type min() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
         D d(.5);
         assert(d.min() == -INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class exponential_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
         D d(.25);
         D::result_type m = d.max();
         assert(m == std::numeric_limits<D::result_type>::infinity());
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class extreme_value_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class extreme_value_distribution
 
 // result_type min() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
         D d(.5, .5);
         assert(d.min() == -INFINITY);
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class gamma_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

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

 // <random>
 
 // template<class IntType = int>
 // class poisson_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
+#include <limits>
 #include <vector>
 #include <numeric>
 
 #include "test_macros.h"
 
 template <class T>
 T sqr(T x) {
   return x * x;

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class poisson_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
         D d(.25);
         D::result_type m = d.max();
         assert(m == std::numeric_limits<int>::max());
     }
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class weibull_distribution
 
 // result_type max() const;
 
 #include <random>
+
 #include <cassert>
+#include <cmath>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
         D d(5, .25);
         D::result_type m = d.max();
         assert(m == INFINITY);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // discrete_distribution();
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         D d;
         std::vector<double> p = d.probabilities();
         assert(p.size() == 1);
         assert(p[0] == 1);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/ctor_func.pass.cpp

 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class UnaryOperation>
 //     discrete_distribution(size_t nw, double xmin, double xmax,
 //                           UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double fw(double x)
 {
     return x+1;
 }
 

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/ctor_init.pass.cpp

 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // discrete_distribution(initializer_list<double> wl);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         D d = {};

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/ctor_iterator.pass.cpp

 
 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class InputIterator>
 //     discrete_distribution(InputIterator firstW, InputIterator lastW);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         double p0[] = {1};

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/ctor_param.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // explicit discrete_distribution(const param_type& parm);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         typedef D::param_type P;

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/param_ctor_default.pass.cpp

 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // param_type(initializer_list<double> wl);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         typedef D::param_type P;
         P pa = {1};
         std::vector<double> p = pa.probabilities();
         assert(p.size() == 1);
         assert(p[0] == 1);
     }
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/param_ctor_func.pass.cpp

 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class UnaryOperation>
 //     param_type(size_t nw, double xmin, double xmax,
 //                           UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double fw(double x)
 {
     return x+1;
 }
 

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/param_ctor_init.pass.cpp

 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // param_type(initializer_list<double> wl);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         typedef D::param_type P;

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/param_ctor_iterator.pass.cpp

 
 // template<class IntType = int>
 // class discrete_distribution
 
 // template<class InputIterator>
 //     param_type(InputIterator firstW, InputIterator lastW);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::discrete_distribution<> D;
         typedef D::param_type P;

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

 // <random>
 
 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // piecewise_constant_distribution(initializer_list<double> wl);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
         D d;

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

 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // template<class UnaryOperation>
 //     piecewise_constant_distribution(size_t nw, result_type xmin,
 //                                     result_type xmax, UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double fw(double x)
 {
     return 2*x;
 }
 

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

 
 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // piecewise_constant_distribution(initializer_list<result_type> bl,
 //                                 UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double f(double x)
 {
     return x*2;
 }
 

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

 // class piecewise_constant_distribution
 
 // template<class InputIterator>
 //     piecewise_constant_distribution(InputIteratorB firstB,
 //                                     InputIteratorB lastB,
 //                                     InputIteratorW firstW);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
         double b[] = {10};

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // explicit piecewise_constant_distribution(const param_type& parm);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
         typedef D::param_type P;

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // param_type();
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
         typedef D::param_type P;

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

 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // template<class UnaryOperation>
 //     param_type(size_t nw, double xmin, double xmax,
 //                           UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double fw(double x)
 {
     return 2*x;
 }
 

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

 // <random>
 
 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // param_type(initializer_list<result_type> bl, UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double f(double x)
 {
     return x*2;
 }
 

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

 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // template<class InputIterator>
 //     param_type(InputIteratorB firstB, InputIteratorB lastB,
 //                InputIteratorW firstW);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_constant_distribution<> D;
         typedef D::param_type P;

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

 // <random>
 
 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // piecewise_linear_distribution(initializer_list<double> wl);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
         D d;

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

 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // template<class UnaryOperation>
 //     piecewise_linear_distribution(size_t nw, result_type xmin,
 //                                     result_type xmax, UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double fw(double x)
 {
     return 2*x;
 }
 

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

 
 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // piecewise_linear_distribution(initializer_list<result_type> bl,
 //                                 UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double f(double x)
 {
     return x*2;
 }
 

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

 // class piecewise_linear_distribution
 
 // template<class InputIterator>
 //     piecewise_linear_distribution(InputIteratorB firstB,
 //                                     InputIteratorB lastB,
 //                                     InputIteratorW firstW);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
         double b[] = {10};

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // explicit piecewise_linear_distribution(const param_type& parm);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
         typedef D::param_type P;

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // param_type();
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
         typedef D::param_type P;

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

 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // template<class UnaryOperation>
 //     param_type(size_t nw, double xmin, double xmax,
 //                           UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double fw(double x)
 {
     return 2*x;
 }
 

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

 // <random>
 
 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // param_type(initializer_list<result_type> bl, UnaryOperation fw);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 double f(double x)
 {
     return x*2;
 }
 

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

 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // template<class InputIterator>
 //     param_type(InputIteratorB firstB, InputIteratorB lastB,
 //                InputIteratorW firstW);
 
 #include <random>
+
 #include <cassert>
+#include <vector>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         typedef std::piecewise_linear_distribution<> D;
         typedef D::param_type P;

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

 
 // explicit uniform_int_distribution(IntType a = 0,
 //                                   IntType b = numeric_limits<IntType>::max()); // before C++20
 // uniform_int_distribution() : uniform_int_distribution(0) {}                    // C++20
 // explicit uniform_int_distribution(IntType a,
 //                                   IntType b = numeric_limits<IntType>::max()); // C++20
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 #if TEST_STD_VER >= 11
 #include "make_implicit.h"
 #include "test_convertible.h"
 #endif
 
 template <class T>

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

 // <random>
 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 
 int main(int, char**) {
 
 #ifndef TEST_HAS_NO_INT128
 
   // Test that values outside of the 64-bit range can be produced.

libcxx/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType, size_t bits, class URNG>
 //     RealType generate_canonical(URNG& g);
 
 #include <random>
+
 #include <cassert>
+#include <limits>
 
 #include "test_macros.h"
 #include "truncate_fp.h"
 
 int main(int, char**)
 {
     {
         typedef std::minstd_rand0 E;