libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/alg.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // <random>
  10
  11 // template <class UIntType, UIntType a, UIntType c, UIntType m>
  12 //   class linear_congruential_engine;
  13
  14 // result_type operator()();
  15
  16 #include <random>
  17 #include <cassert>
  18
  19 #include "test_macros.h"
  20
  21 int main(int, char**)
  22 {
  23     typedef unsigned long long T;
  24
  25     // m might overflow, but the overflow is OK so it shouldn't use Schrage's algorithm
  26     typedef std::linear_congruential_engine<T, 25214903917ull, 1, (1ull << 48)> E1;
  27     E1 e1;
  28     // make sure the right algorithm was used
  29     assert(e1() == 25214903918ull);
  30     assert(e1() == 205774354444503ull);
  31     assert(e1() == 158051849450892ull);
  32     // make sure result is in bounds
  33     assert(e1() < (1ull << 48));
  34     assert(e1() < (1ull << 48));
  35     assert(e1() < (1ull << 48));
  36     assert(e1() < (1ull << 48));
  37     assert(e1() < (1ull << 48));
  38
  39     // m might overflow. The overflow is not OK and result will be in bounds
  40     // so we should use Schrage's algorithm
  41     typedef std::linear_congruential_engine<T, (1ull << 32), 0, (1ull << 63) + 1ull> E2;
  42     E2 e2;
  43     // make sure Schrage's algorithm is used (it would be 0s after the first otherwise)
  44     assert(e2() == (1ull << 32));
  45     assert(e2() == (1ull << 63) - 1ull);
  46     assert(e2() == (1ull << 63) - 0x1ffffffffull);
  47     // make sure result is in bounds
  48     assert(e2() < (1ull << 63) + 1);
  49     assert(e2() < (1ull << 63) + 1);
  50     assert(e2() < (1ull << 63) + 1);
  51     assert(e2() < (1ull << 63) + 1);
  52     assert(e2() < (1ull << 63) + 1);
  53
  54     // m might overflow. The overflow is not OK and result will be in bounds
  55     // so we should use Schrage's algorithm. m is even
  56     typedef std::linear_congruential_engine<T, 0x18000001ull, 0x12347ull, (3ull << 56)> E3;
  57     E3 e3;
  58     // make sure Schrage's algorithm is used
  59     assert(e3() == 0x18012348ull);
  60     assert(e3() == 0x2401b4ed802468full);
  61     assert(e3() == 0x18051ec400369d6ull);
  62     // make sure result is in bounds
  63     assert(e3() < (3ull << 56));
  64     assert(e3() < (3ull << 56));
  65     assert(e3() < (3ull << 56));
  66     assert(e3() < (3ull << 56));
  67     assert(e3() < (3ull << 56));
  68
  69     // 32-bit case:
  70     // m might overflow. The overflow is not OK, result will be in bounds,
  71     // and Schrage's algorithm is incompatible here. Need to use 64 bit arithmetic.
  72     typedef std::linear_congruential_engine<unsigned, 0x10009u, 0u, 0x7fffffffu> E4;
  73     E4 e4;
  74     // make sure enough precision is used
  75     assert(e4() == 0x10009u);
  76     assert(e4() == 0x120053u);
  77     assert(e4() == 0xf5030fu);
  78     // make sure result is in bounds
  79     assert(e4() < 0x7fffffffu);
  80     assert(e4() < 0x7fffffffu);
  81     assert(e4() < 0x7fffffffu);
  82     assert(e4() < 0x7fffffffu);
  83     assert(e4() < 0x7fffffffu);
  84
  85 #ifndef TEST_HAS_NO_INT128
  86     // m might overflow. The overflow is not OK, result will be in bounds,
  87     // and Schrage's algorithm is incompatible here. Need to use 128 bit arithmetic.
  88     typedef std::linear_congruential_engine<T, 0x100000001ull, 0ull, (1ull << 61) - 1ull> E5;
  89     E5 e5;
  90     // make sure enough precision is used
  91     assert(e5() == 0x100000001ull);
  92     assert(e5() == 0x200000009ull);
  93     assert(e5() == 0xb00000019ull);
  94     // make sure result is in bounds
  95     assert(e5() < (1ull << 61) - 1ull);
  96     assert(e5() < (1ull << 61) - 1ull);
  97     assert(e5() < (1ull << 61) - 1ull);
  98     assert(e5() < (1ull << 61) - 1ull);
  99     assert(e5() < (1ull << 61) - 1ull);
 100 #endif
 101
 102     // m will not overflow so we should not use Schrage's algorithm
 103     typedef std::linear_congruential_engine<T, 1ull, 1, (1ull << 48)> E6;
 104     E6 e6;
 105     // make sure the correct algorithm was used
 106     assert(e6() == 2ull);
 107     assert(e6() == 3ull);
 108     assert(e6() == 4ull);
 109     // make sure result is in bounds
 110     assert(e6() < (1ull << 48));
 111     assert(e6() < (1ull << 48));
 112     assert(e6() < (1ull << 48));
 113     assert(e6() < (1ull << 48));
 114     assert(e6() < (1ull << 48));
 115
 116     return 0;
 117 }