1 /* 2 * PCG Random Number Generation for C. 3 * 4 * Copyright 2014-2019 Melissa O'Neill <oneill@pcg-random.org>, 5 * and the PCG Project contributors. 6 * 7 * SPDX-License-Identifier: (Apache-2.0 OR MIT) 8 * 9 * Licensed under the Apache License, Version 2.0 (provided in 10 * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0) 11 * or under the MIT license (provided in LICENSE-MIT.txt and at 12 * http://opensource.org/licenses/MIT), at your option. This file may not 13 * be copied, modified, or distributed except according to those terms. 14 * 15 * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either 16 * express or implied. See your chosen license for details. 17 * 18 * For additional information about the PCG random number generation scheme, 19 * visit http://www.pcg-random.org/. 20 */ 21 22 /* 23 * This code is derived from the canonical C++ PCG implementation, which 24 * has many additional features and is preferable if you can use C++ in 25 * your project. 26 * 27 * Much of the derivation was performed mechanically. In particular, the 28 * output functions were generated by compiling the C++ output functions 29 * into LLVM bitcode and then transforming that using the LLVM C backend 30 * (from https://github.com/draperlaboratory/llvm-cbe), and then 31 * postprocessing and hand editing the output. 32 * 33 * Much of the remaining code was generated by C-preprocessor metaprogramming. 34 */ 35 36 #ifndef PCG_VARIANTS_H_INCLUDED 37 #define PCG_VARIANTS_H_INCLUDED 1 38 39 #include <inttypes.h> 40 41 #if __SIZEOF_INT128__ 42 typedef __uint128_t pcg128_t; 43 #define PCG_128BIT_CONSTANT(high,low) \ 44 ((((pcg128_t)high) << 64) + low) 45 #define PCG_HAS_128BIT_OPS 1 46 #endif 47 48 #if __GNUC_GNU_INLINE__ && !defined(__cplusplus) 49 #error Nonstandard GNU inlining semantics. Compile with -std=c99 or better. 50 /* We could instead use macros PCG_INLINE and PCG_EXTERN_INLINE 51 but better to just reject ancient C code. */ 52 #endif 53 54 #if __cplusplus 55 extern "C" { 56 #endif 57 58 /* 59 * Rotate helper functions. 60 */ 61 62 inline uint8_t pcg_rotr_8(uint8_t value, unsigned int rot) 63 { 64 /* Unfortunately, clang is kinda pathetic when it comes to properly 65 * recognizing idiomatic rotate code, so for clang we actually provide 66 * assembler directives (enabled with PCG_USE_INLINE_ASM). Boo, hiss. 67 */ 68 #if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__) 69 asm ("rorb %%cl, %0" : "=r" (value) : "0" (value), "c" (rot)); 70 return value; 71 #else 72 return (value >> rot) | (value << ((- rot) & 7)); 73 #endif 74 } 75 76 inline uint16_t pcg_rotr_16(uint16_t value, unsigned int rot) 77 { 78 #if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__) 79 asm ("rorw %%cl, %0" : "=r" (value) : "0" (value), "c" (rot)); 80 return value; 81 #else 82 return (value >> rot) | (value << ((- rot) & 15)); 83 #endif 84 } 85 86 inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot) 87 { 88 #if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__) 89 asm ("rorl %%cl, %0" : "=r" (value) : "0" (value), "c" (rot)); 90 return value; 91 #else 92 return (value >> rot) | (value << ((- rot) & 31)); 93 #endif 94 } 95 96 inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot) 97 { 98 #if 0 && PCG_USE_INLINE_ASM && __clang__ && __x86_64__ 99 /* For whatever reason, clang actually *does* generate rotq by 100 itself, so we don't need this code. */ 101 asm ("rorq %%cl, %0" : "=r" (value) : "0" (value), "c" (rot)); 102 return value; 103 #else 104 return (value >> rot) | (value << ((- rot) & 63)); 105 #endif 106 } 107 108 #if PCG_HAS_128BIT_OPS 109 inline pcg128_t pcg_rotr_128(pcg128_t value, unsigned int rot) 110 { 111 return (value >> rot) | (value << ((- rot) & 127)); 112 } 113 #endif 114 115 /* 116 * Output functions. These are the core of the PCG generation scheme. 117 */ 118 119 /* XSH RS */ 120 121 inline uint8_t pcg_output_xsh_rs_16_8(uint16_t state) 122 { 123 return (uint8_t)(((state >> 7u) ^ state) >> ((state >> 14u) + 3u)); 124 } 125 126 inline uint16_t pcg_output_xsh_rs_32_16(uint32_t state) 127 { 128 return (uint16_t)(((state >> 11u) ^ state) >> ((state >> 30u) + 11u)); 129 } 130 131 inline uint32_t pcg_output_xsh_rs_64_32(uint64_t state) 132 { 133 134 return (uint32_t)(((state >> 22u) ^ state) >> ((state >> 61u) + 22u)); 135 } 136 137 #if PCG_HAS_128BIT_OPS 138 inline uint64_t pcg_output_xsh_rs_128_64(pcg128_t state) 139 { 140 return (uint64_t)(((state >> 43u) ^ state) >> ((state >> 124u) + 45u)); 141 } 142 #endif 143 144 /* XSH RR */ 145 146 inline uint8_t pcg_output_xsh_rr_16_8(uint16_t state) 147 { 148 return pcg_rotr_8(((state >> 5u) ^ state) >> 5u, state >> 13u); 149 } 150 151 inline uint16_t pcg_output_xsh_rr_32_16(uint32_t state) 152 { 153 return pcg_rotr_16(((state >> 10u) ^ state) >> 12u, state >> 28u); 154 } 155 156 inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state) 157 { 158 return pcg_rotr_32(((state >> 18u) ^ state) >> 27u, state >> 59u); 159 } 160 161 #if PCG_HAS_128BIT_OPS 162 inline uint64_t pcg_output_xsh_rr_128_64(pcg128_t state) 163 { 164 return pcg_rotr_64(((state >> 35u) ^ state) >> 58u, state >> 122u); 165 } 166 #endif 167 168 /* RXS M XS */ 169 170 inline uint8_t pcg_output_rxs_m_xs_8_8(uint8_t state) 171 { 172 uint8_t word = ((state >> ((state >> 6u) + 2u)) ^ state) * 217u; 173 return (word >> 6u) ^ word; 174 } 175 176 inline uint16_t pcg_output_rxs_m_xs_16_16(uint16_t state) 177 { 178 uint16_t word = ((state >> ((state >> 13u) + 3u)) ^ state) * 62169u; 179 return (word >> 11u) ^ word; 180 } 181 182 inline uint32_t pcg_output_rxs_m_xs_32_32(uint32_t state) 183 { 184 uint32_t word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u; 185 return (word >> 22u) ^ word; 186 } 187 188 inline uint64_t pcg_output_rxs_m_xs_64_64(uint64_t state) 189 { 190 uint64_t word = ((state >> ((state >> 59u) + 5u)) ^ state) 191 * 12605985483714917081ull; 192 return (word >> 43u) ^ word; 193 } 194 195 #if PCG_HAS_128BIT_OPS 196 inline pcg128_t pcg_output_rxs_m_xs_128_128(pcg128_t state) 197 { 198 pcg128_t word = ((state >> ((state >> 122u) + 6u)) ^ state) 199 * (PCG_128BIT_CONSTANT(17766728186571221404ULL, 200 12605985483714917081ULL)); 201 /* 327738287884841127335028083622016905945 */ 202 return (word >> 86u) ^ word; 203 } 204 #endif 205 206 /* RXS M */ 207 208 inline uint8_t pcg_output_rxs_m_16_8(uint16_t state) 209 { 210 return (((state >> ((state >> 13u) + 3u)) ^ state) * 62169u) >> 8u; 211 } 212 213 inline uint16_t pcg_output_rxs_m_32_16(uint32_t state) 214 { 215 return (((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u) >> 16u; 216 } 217 218 inline uint32_t pcg_output_rxs_m_64_32(uint64_t state) 219 { 220 return (((state >> ((state >> 59u) + 5u)) ^ state) 221 * 12605985483714917081ull) >> 32u; 222 } 223 224 #if PCG_HAS_128BIT_OPS 225 inline uint64_t pcg_output_rxs_m_128_64(pcg128_t state) 226 { 227 return (((state >> ((state >> 122u) + 6u)) ^ state) 228 * (PCG_128BIT_CONSTANT(17766728186571221404ULL, 229 12605985483714917081ULL))) >> 64u; 230 /* 327738287884841127335028083622016905945 */ 231 } 232 #endif 233 234 /* XSL RR (only defined for >= 64 bits) */ 235 236 inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state) 237 { 238 return pcg_rotr_32(((uint32_t)(state >> 32u)) ^ (uint32_t)state, 239 state >> 59u); 240 } 241 242 #if PCG_HAS_128BIT_OPS 243 inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state) 244 { 245 return pcg_rotr_64(((uint64_t)(state >> 64u)) ^ (uint64_t)state, 246 state >> 122u); 247 } 248 #endif 249 250 /* XSL RR RR (only defined for >= 64 bits) */ 251 252 inline uint64_t pcg_output_xsl_rr_rr_64_64(uint64_t state) 253 { 254 uint32_t rot1 = (uint32_t)(state >> 59u); 255 uint32_t high = (uint32_t)(state >> 32u); 256 uint32_t low = (uint32_t)state; 257 uint32_t xored = high ^ low; 258 uint32_t newlow = pcg_rotr_32(xored, rot1); 259 uint32_t newhigh = pcg_rotr_32(high, newlow & 31u); 260 return (((uint64_t)newhigh) << 32u) | newlow; 261 } 262 263 #if PCG_HAS_128BIT_OPS 264 inline pcg128_t pcg_output_xsl_rr_rr_128_128(pcg128_t state) 265 { 266 uint32_t rot1 = (uint32_t)(state >> 122u); 267 uint64_t high = (uint64_t)(state >> 64u); 268 uint64_t low = (uint64_t)state; 269 uint64_t xored = high ^ low; 270 uint64_t newlow = pcg_rotr_64(xored, rot1); 271 uint64_t newhigh = pcg_rotr_64(high, newlow & 63u); 272 return (((pcg128_t)newhigh) << 64u) | newlow; 273 } 274 #endif 275 276 #define PCG_DEFAULT_MULTIPLIER_8 141U 277 #define PCG_DEFAULT_MULTIPLIER_16 12829U 278 #define PCG_DEFAULT_MULTIPLIER_32 747796405U 279 #define PCG_DEFAULT_MULTIPLIER_64 6364136223846793005ULL 280 281 #define PCG_DEFAULT_INCREMENT_8 77U 282 #define PCG_DEFAULT_INCREMENT_16 47989U 283 #define PCG_DEFAULT_INCREMENT_32 2891336453U 284 #define PCG_DEFAULT_INCREMENT_64 1442695040888963407ULL 285 286 #if PCG_HAS_128BIT_OPS 287 #define PCG_DEFAULT_MULTIPLIER_128 \ 288 PCG_128BIT_CONSTANT(2549297995355413924ULL,4865540595714422341ULL) 289 #define PCG_DEFAULT_INCREMENT_128 \ 290 PCG_128BIT_CONSTANT(6364136223846793005ULL,1442695040888963407ULL) 291 #endif 292 293 /* 294 * Static initialization constants (if you can't call srandom for some 295 * bizarre reason). 296 */ 297 298 #define PCG_STATE_ONESEQ_8_INITIALIZER { 0xd7U } 299 #define PCG_STATE_ONESEQ_16_INITIALIZER { 0x20dfU } 300 #define PCG_STATE_ONESEQ_32_INITIALIZER { 0x46b56677U } 301 #define PCG_STATE_ONESEQ_64_INITIALIZER { 0x4d595df4d0f33173ULL } 302 #if PCG_HAS_128BIT_OPS 303 #define PCG_STATE_ONESEQ_128_INITIALIZER \ 304 { PCG_128BIT_CONSTANT(0xb8dc10e158a92392ULL, 0x98046df007ec0a53ULL) } 305 #endif 306 307 #define PCG_STATE_UNIQUE_8_INITIALIZER PCG_STATE_ONESEQ_8_INITIALIZER 308 #define PCG_STATE_UNIQUE_16_INITIALIZER PCG_STATE_ONESEQ_16_INITIALIZER 309 #define PCG_STATE_UNIQUE_32_INITIALIZER PCG_STATE_ONESEQ_32_INITIALIZER 310 #define PCG_STATE_UNIQUE_64_INITIALIZER PCG_STATE_ONESEQ_64_INITIALIZER 311 #if PCG_HAS_128BIT_OPS 312 #define PCG_STATE_UNIQUE_128_INITIALIZER PCG_STATE_ONESEQ_128_INITIALIZER 313 #endif 314 315 #define PCG_STATE_MCG_8_INITIALIZER { 0xe5U } 316 #define PCG_STATE_MCG_16_INITIALIZER { 0xa5e5U } 317 #define PCG_STATE_MCG_32_INITIALIZER { 0xd15ea5e5U } 318 #define PCG_STATE_MCG_64_INITIALIZER { 0xcafef00dd15ea5e5ULL } 319 #if PCG_HAS_128BIT_OPS 320 #define PCG_STATE_MCG_128_INITIALIZER \ 321 { PCG_128BIT_CONSTANT(0x0000000000000000ULL, 0xcafef00dd15ea5e5ULL) } 322 #endif 323 324 #define PCG_STATE_SETSEQ_8_INITIALIZER { 0x9bU, 0xdbU } 325 #define PCG_STATE_SETSEQ_16_INITIALIZER { 0xe39bU, 0x5bdbU } 326 #define PCG_STATE_SETSEQ_32_INITIALIZER { 0xec02d89bU, 0x94b95bdbU } 327 #define PCG_STATE_SETSEQ_64_INITIALIZER \ 328 { 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL } 329 #if PCG_HAS_128BIT_OPS 330 #define PCG_STATE_SETSEQ_128_INITIALIZER \ 331 { PCG_128BIT_CONSTANT(0x979c9a98d8462005ULL, 0x7d3e9cb6cfe0549bULL), \ 332 PCG_128BIT_CONSTANT(0x0000000000000001ULL, 0xda3e39cb94b95bdbULL) } 333 #endif 334 335 /* Representations for the oneseq, mcg, and unique variants */ 336 337 struct pcg_state_8 { 338 uint8_t state; 339 }; 340 341 struct pcg_state_16 { 342 uint16_t state; 343 }; 344 345 struct pcg_state_32 { 346 uint32_t state; 347 }; 348 349 struct pcg_state_64 { 350 uint64_t state; 351 }; 352 353 #if PCG_HAS_128BIT_OPS 354 struct pcg_state_128 { 355 pcg128_t state; 356 }; 357 #endif 358 359 /* Representations setseq variants */ 360 361 struct pcg_state_setseq_8 { 362 uint8_t state; 363 uint8_t inc; 364 }; 365 366 struct pcg_state_setseq_16 { 367 uint16_t state; 368 uint16_t inc; 369 }; 370 371 struct pcg_state_setseq_32 { 372 uint32_t state; 373 uint32_t inc; 374 }; 375 376 struct pcg_state_setseq_64 { 377 uint64_t state; 378 uint64_t inc; 379 }; 380 381 #if PCG_HAS_128BIT_OPS 382 struct pcg_state_setseq_128 { 383 pcg128_t state; 384 pcg128_t inc; 385 }; 386 #endif 387 388 /* Multi-step advance functions (jump-ahead, jump-back) */ 389 390 extern uint8_t pcg_advance_lcg_8(uint8_t state, uint8_t delta, uint8_t cur_mult, 391 uint8_t cur_plus); 392 extern uint16_t pcg_advance_lcg_16(uint16_t state, uint16_t delta, 393 uint16_t cur_mult, uint16_t cur_plus); 394 extern uint32_t pcg_advance_lcg_32(uint32_t state, uint32_t delta, 395 uint32_t cur_mult, uint32_t cur_plus); 396 extern uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta, 397 uint64_t cur_mult, uint64_t cur_plus); 398 399 #if PCG_HAS_128BIT_OPS 400 extern pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, 401 pcg128_t cur_mult, pcg128_t cur_plus); 402 #endif 403 404 /* Functions to advance the underlying LCG, one version for each size and 405 * each style. These functions are considered semi-private. There is rarely 406 * a good reason to call them directly. 407 */ 408 409 inline void pcg_oneseq_8_step_r(struct pcg_state_8* rng) 410 { 411 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8 412 + PCG_DEFAULT_INCREMENT_8; 413 } 414 415 inline void pcg_oneseq_8_advance_r(struct pcg_state_8* rng, uint8_t delta) 416 { 417 rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, 418 PCG_DEFAULT_INCREMENT_8); 419 } 420 421 inline void pcg_mcg_8_step_r(struct pcg_state_8* rng) 422 { 423 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8; 424 } 425 426 inline void pcg_mcg_8_advance_r(struct pcg_state_8* rng, uint8_t delta) 427 { 428 rng->state 429 = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, 0u); 430 } 431 432 inline void pcg_unique_8_step_r(struct pcg_state_8* rng) 433 { 434 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8 435 + (uint8_t)(((intptr_t)rng) | 1u); 436 } 437 438 inline void pcg_unique_8_advance_r(struct pcg_state_8* rng, uint8_t delta) 439 { 440 rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, 441 (uint8_t)(((intptr_t)rng) | 1u)); 442 } 443 444 inline void pcg_setseq_8_step_r(struct pcg_state_setseq_8* rng) 445 { 446 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8 + rng->inc; 447 } 448 449 inline void pcg_setseq_8_advance_r(struct pcg_state_setseq_8* rng, 450 uint8_t delta) 451 { 452 rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, 453 rng->inc); 454 } 455 456 inline void pcg_oneseq_16_step_r(struct pcg_state_16* rng) 457 { 458 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16 459 + PCG_DEFAULT_INCREMENT_16; 460 } 461 462 inline void pcg_oneseq_16_advance_r(struct pcg_state_16* rng, uint16_t delta) 463 { 464 rng->state = pcg_advance_lcg_16( 465 rng->state, delta, PCG_DEFAULT_MULTIPLIER_16, PCG_DEFAULT_INCREMENT_16); 466 } 467 468 inline void pcg_mcg_16_step_r(struct pcg_state_16* rng) 469 { 470 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16; 471 } 472 473 inline void pcg_mcg_16_advance_r(struct pcg_state_16* rng, uint16_t delta) 474 { 475 rng->state 476 = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16, 0u); 477 } 478 479 inline void pcg_unique_16_step_r(struct pcg_state_16* rng) 480 { 481 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16 482 + (uint16_t)(((intptr_t)rng) | 1u); 483 } 484 485 inline void pcg_unique_16_advance_r(struct pcg_state_16* rng, uint16_t delta) 486 { 487 rng->state 488 = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16, 489 (uint16_t)(((intptr_t)rng) | 1u)); 490 } 491 492 inline void pcg_setseq_16_step_r(struct pcg_state_setseq_16* rng) 493 { 494 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16 + rng->inc; 495 } 496 497 inline void pcg_setseq_16_advance_r(struct pcg_state_setseq_16* rng, 498 uint16_t delta) 499 { 500 rng->state = pcg_advance_lcg_16(rng->state, delta, 501 PCG_DEFAULT_MULTIPLIER_16, rng->inc); 502 } 503 504 inline void pcg_oneseq_32_step_r(struct pcg_state_32* rng) 505 { 506 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32 507 + PCG_DEFAULT_INCREMENT_32; 508 } 509 510 inline void pcg_oneseq_32_advance_r(struct pcg_state_32* rng, uint32_t delta) 511 { 512 rng->state = pcg_advance_lcg_32( 513 rng->state, delta, PCG_DEFAULT_MULTIPLIER_32, PCG_DEFAULT_INCREMENT_32); 514 } 515 516 inline void pcg_mcg_32_step_r(struct pcg_state_32* rng) 517 { 518 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32; 519 } 520 521 inline void pcg_mcg_32_advance_r(struct pcg_state_32* rng, uint32_t delta) 522 { 523 rng->state 524 = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32, 0u); 525 } 526 527 inline void pcg_unique_32_step_r(struct pcg_state_32* rng) 528 { 529 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32 530 + (uint32_t)(((intptr_t)rng) | 1u); 531 } 532 533 inline void pcg_unique_32_advance_r(struct pcg_state_32* rng, uint32_t delta) 534 { 535 rng->state 536 = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32, 537 (uint32_t)(((intptr_t)rng) | 1u)); 538 } 539 540 inline void pcg_setseq_32_step_r(struct pcg_state_setseq_32* rng) 541 { 542 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32 + rng->inc; 543 } 544 545 inline void pcg_setseq_32_advance_r(struct pcg_state_setseq_32* rng, 546 uint32_t delta) 547 { 548 rng->state = pcg_advance_lcg_32(rng->state, delta, 549 PCG_DEFAULT_MULTIPLIER_32, rng->inc); 550 } 551 552 inline void pcg_oneseq_64_step_r(struct pcg_state_64* rng) 553 { 554 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 555 + PCG_DEFAULT_INCREMENT_64; 556 } 557 558 inline void pcg_oneseq_64_advance_r(struct pcg_state_64* rng, uint64_t delta) 559 { 560 rng->state = pcg_advance_lcg_64( 561 rng->state, delta, PCG_DEFAULT_MULTIPLIER_64, PCG_DEFAULT_INCREMENT_64); 562 } 563 564 inline void pcg_mcg_64_step_r(struct pcg_state_64* rng) 565 { 566 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64; 567 } 568 569 inline void pcg_mcg_64_advance_r(struct pcg_state_64* rng, uint64_t delta) 570 { 571 rng->state 572 = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64, 0u); 573 } 574 575 inline void pcg_unique_64_step_r(struct pcg_state_64* rng) 576 { 577 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 578 + (uint64_t)(((intptr_t)rng) | 1u); 579 } 580 581 inline void pcg_unique_64_advance_r(struct pcg_state_64* rng, uint64_t delta) 582 { 583 rng->state 584 = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64, 585 (uint64_t)(((intptr_t)rng) | 1u)); 586 } 587 588 inline void pcg_setseq_64_step_r(struct pcg_state_setseq_64* rng) 589 { 590 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 + rng->inc; 591 } 592 593 inline void pcg_setseq_64_advance_r(struct pcg_state_setseq_64* rng, 594 uint64_t delta) 595 { 596 rng->state = pcg_advance_lcg_64(rng->state, delta, 597 PCG_DEFAULT_MULTIPLIER_64, rng->inc); 598 } 599 600 #if PCG_HAS_128BIT_OPS 601 inline void pcg_oneseq_128_step_r(struct pcg_state_128* rng) 602 { 603 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 604 + PCG_DEFAULT_INCREMENT_128; 605 } 606 #endif 607 608 #if PCG_HAS_128BIT_OPS 609 inline void pcg_oneseq_128_advance_r(struct pcg_state_128* rng, pcg128_t delta) 610 { 611 rng->state 612 = pcg_advance_lcg_128(rng->state, delta, PCG_DEFAULT_MULTIPLIER_128, 613 PCG_DEFAULT_INCREMENT_128); 614 } 615 #endif 616 617 #if PCG_HAS_128BIT_OPS 618 inline void pcg_mcg_128_step_r(struct pcg_state_128* rng) 619 { 620 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128; 621 } 622 #endif 623 624 #if PCG_HAS_128BIT_OPS 625 inline void pcg_mcg_128_advance_r(struct pcg_state_128* rng, pcg128_t delta) 626 { 627 rng->state = pcg_advance_lcg_128(rng->state, delta, 628 PCG_DEFAULT_MULTIPLIER_128, 0u); 629 } 630 #endif 631 632 #if PCG_HAS_128BIT_OPS 633 inline void pcg_unique_128_step_r(struct pcg_state_128* rng) 634 { 635 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 636 + (pcg128_t)(((intptr_t)rng) | 1u); 637 } 638 #endif 639 640 #if PCG_HAS_128BIT_OPS 641 inline void pcg_unique_128_advance_r(struct pcg_state_128* rng, pcg128_t delta) 642 { 643 rng->state 644 = pcg_advance_lcg_128(rng->state, delta, PCG_DEFAULT_MULTIPLIER_128, 645 (pcg128_t)(((intptr_t)rng) | 1u)); 646 } 647 #endif 648 649 #if PCG_HAS_128BIT_OPS 650 inline void pcg_setseq_128_step_r(struct pcg_state_setseq_128* rng) 651 { 652 rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 + rng->inc; 653 } 654 #endif 655 656 #if PCG_HAS_128BIT_OPS 657 inline void pcg_setseq_128_advance_r(struct pcg_state_setseq_128* rng, 658 pcg128_t delta) 659 { 660 rng->state = pcg_advance_lcg_128(rng->state, delta, 661 PCG_DEFAULT_MULTIPLIER_128, rng->inc); 662 } 663 #endif 664 665 /* Functions to seed the RNG state, one version for each size and each 666 * style. Unlike the step functions, regular users can and should call 667 * these functions. 668 */ 669 670 inline void pcg_oneseq_8_srandom_r(struct pcg_state_8* rng, uint8_t initstate) 671 { 672 rng->state = 0U; 673 pcg_oneseq_8_step_r(rng); 674 rng->state += initstate; 675 pcg_oneseq_8_step_r(rng); 676 } 677 678 inline void pcg_mcg_8_srandom_r(struct pcg_state_8* rng, uint8_t initstate) 679 { 680 rng->state = initstate | 1u; 681 } 682 683 inline void pcg_unique_8_srandom_r(struct pcg_state_8* rng, uint8_t initstate) 684 { 685 rng->state = 0U; 686 pcg_unique_8_step_r(rng); 687 rng->state += initstate; 688 pcg_unique_8_step_r(rng); 689 } 690 691 inline void pcg_setseq_8_srandom_r(struct pcg_state_setseq_8* rng, 692 uint8_t initstate, uint8_t initseq) 693 { 694 rng->state = 0U; 695 rng->inc = (initseq << 1u) | 1u; 696 pcg_setseq_8_step_r(rng); 697 rng->state += initstate; 698 pcg_setseq_8_step_r(rng); 699 } 700 701 inline void pcg_oneseq_16_srandom_r(struct pcg_state_16* rng, 702 uint16_t initstate) 703 { 704 rng->state = 0U; 705 pcg_oneseq_16_step_r(rng); 706 rng->state += initstate; 707 pcg_oneseq_16_step_r(rng); 708 } 709 710 inline void pcg_mcg_16_srandom_r(struct pcg_state_16* rng, uint16_t initstate) 711 { 712 rng->state = initstate | 1u; 713 } 714 715 inline void pcg_unique_16_srandom_r(struct pcg_state_16* rng, 716 uint16_t initstate) 717 { 718 rng->state = 0U; 719 pcg_unique_16_step_r(rng); 720 rng->state += initstate; 721 pcg_unique_16_step_r(rng); 722 } 723 724 inline void pcg_setseq_16_srandom_r(struct pcg_state_setseq_16* rng, 725 uint16_t initstate, uint16_t initseq) 726 { 727 rng->state = 0U; 728 rng->inc = (initseq << 1u) | 1u; 729 pcg_setseq_16_step_r(rng); 730 rng->state += initstate; 731 pcg_setseq_16_step_r(rng); 732 } 733 734 inline void pcg_oneseq_32_srandom_r(struct pcg_state_32* rng, 735 uint32_t initstate) 736 { 737 rng->state = 0U; 738 pcg_oneseq_32_step_r(rng); 739 rng->state += initstate; 740 pcg_oneseq_32_step_r(rng); 741 } 742 743 inline void pcg_mcg_32_srandom_r(struct pcg_state_32* rng, uint32_t initstate) 744 { 745 rng->state = initstate | 1u; 746 } 747 748 inline void pcg_unique_32_srandom_r(struct pcg_state_32* rng, 749 uint32_t initstate) 750 { 751 rng->state = 0U; 752 pcg_unique_32_step_r(rng); 753 rng->state += initstate; 754 pcg_unique_32_step_r(rng); 755 } 756 757 inline void pcg_setseq_32_srandom_r(struct pcg_state_setseq_32* rng, 758 uint32_t initstate, uint32_t initseq) 759 { 760 rng->state = 0U; 761 rng->inc = (initseq << 1u) | 1u; 762 pcg_setseq_32_step_r(rng); 763 rng->state += initstate; 764 pcg_setseq_32_step_r(rng); 765 } 766 767 inline void pcg_oneseq_64_srandom_r(struct pcg_state_64* rng, 768 uint64_t initstate) 769 { 770 rng->state = 0U; 771 pcg_oneseq_64_step_r(rng); 772 rng->state += initstate; 773 pcg_oneseq_64_step_r(rng); 774 } 775 776 inline void pcg_mcg_64_srandom_r(struct pcg_state_64* rng, uint64_t initstate) 777 { 778 rng->state = initstate | 1u; 779 } 780 781 inline void pcg_unique_64_srandom_r(struct pcg_state_64* rng, 782 uint64_t initstate) 783 { 784 rng->state = 0U; 785 pcg_unique_64_step_r(rng); 786 rng->state += initstate; 787 pcg_unique_64_step_r(rng); 788 } 789 790 inline void pcg_setseq_64_srandom_r(struct pcg_state_setseq_64* rng, 791 uint64_t initstate, uint64_t initseq) 792 { 793 rng->state = 0U; 794 rng->inc = (initseq << 1u) | 1u; 795 pcg_setseq_64_step_r(rng); 796 rng->state += initstate; 797 pcg_setseq_64_step_r(rng); 798 } 799 800 #if PCG_HAS_128BIT_OPS 801 inline void pcg_oneseq_128_srandom_r(struct pcg_state_128* rng, 802 pcg128_t initstate) 803 { 804 rng->state = 0U; 805 pcg_oneseq_128_step_r(rng); 806 rng->state += initstate; 807 pcg_oneseq_128_step_r(rng); 808 } 809 #endif 810 811 #if PCG_HAS_128BIT_OPS 812 inline void pcg_mcg_128_srandom_r(struct pcg_state_128* rng, pcg128_t initstate) 813 { 814 rng->state = initstate | 1u; 815 } 816 #endif 817 818 #if PCG_HAS_128BIT_OPS 819 inline void pcg_unique_128_srandom_r(struct pcg_state_128* rng, 820 pcg128_t initstate) 821 { 822 rng->state = 0U; 823 pcg_unique_128_step_r(rng); 824 rng->state += initstate; 825 pcg_unique_128_step_r(rng); 826 } 827 #endif 828 829 #if PCG_HAS_128BIT_OPS 830 inline void pcg_setseq_128_srandom_r(struct pcg_state_setseq_128* rng, 831 pcg128_t initstate, pcg128_t initseq) 832 { 833 rng->state = 0U; 834 rng->inc = (initseq << 1u) | 1u; 835 pcg_setseq_128_step_r(rng); 836 rng->state += initstate; 837 pcg_setseq_128_step_r(rng); 838 } 839 #endif 840 841 /* Now, finally we create each of the individual generators. We provide 842 * a random_r function that provides a random number of the appropriate 843 * type (using the full range of the type) and a boundedrand_r version 844 * that provides 845 * 846 * Implementation notes for boundedrand_r: 847 * 848 * To avoid bias, we need to make the range of the RNG a multiple of 849 * bound, which we do by dropping output less than a threshold. 850 * Let's consider a 32-bit case... A naive scheme to calculate the 851 * threshold would be to do 852 * 853 * uint32_t threshold = 0x100000000ull % bound; 854 * 855 * but 64-bit div/mod is slower than 32-bit div/mod (especially on 856 * 32-bit platforms). In essence, we do 857 * 858 * uint32_t threshold = (0x100000000ull-bound) % bound; 859 * 860 * because this version will calculate the same modulus, but the LHS 861 * value is less than 2^32. 862 * 863 * (Note that using modulo is only wise for good RNGs, poorer RNGs 864 * such as raw LCGs do better using a technique based on division.) 865 * Empricical tests show that division is preferable to modulus for 866 * reducting the range of an RNG. It's faster, and sometimes it can 867 * even be statistically prefereable. 868 */ 869 870 /* Generation functions for XSH RS */ 871 872 inline uint8_t pcg_oneseq_16_xsh_rs_8_random_r(struct pcg_state_16* rng) 873 { 874 uint16_t oldstate = rng->state; 875 pcg_oneseq_16_step_r(rng); 876 return pcg_output_xsh_rs_16_8(oldstate); 877 } 878 879 inline uint8_t pcg_oneseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng, 880 uint8_t bound) 881 { 882 uint8_t threshold = ((uint8_t)(-bound)) % bound; 883 for (;;) { 884 uint8_t r = pcg_oneseq_16_xsh_rs_8_random_r(rng); 885 if (r >= threshold) 886 return r % bound; 887 } 888 } 889 890 inline uint16_t pcg_oneseq_32_xsh_rs_16_random_r(struct pcg_state_32* rng) 891 { 892 uint32_t oldstate = rng->state; 893 pcg_oneseq_32_step_r(rng); 894 return pcg_output_xsh_rs_32_16(oldstate); 895 } 896 897 inline uint16_t pcg_oneseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng, 898 uint16_t bound) 899 { 900 uint16_t threshold = ((uint16_t)(-bound)) % bound; 901 for (;;) { 902 uint16_t r = pcg_oneseq_32_xsh_rs_16_random_r(rng); 903 if (r >= threshold) 904 return r % bound; 905 } 906 } 907 908 inline uint32_t pcg_oneseq_64_xsh_rs_32_random_r(struct pcg_state_64* rng) 909 { 910 uint64_t oldstate = rng->state; 911 pcg_oneseq_64_step_r(rng); 912 return pcg_output_xsh_rs_64_32(oldstate); 913 } 914 915 inline uint32_t pcg_oneseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng, 916 uint32_t bound) 917 { 918 uint32_t threshold = -bound % bound; 919 for (;;) { 920 uint32_t r = pcg_oneseq_64_xsh_rs_32_random_r(rng); 921 if (r >= threshold) 922 return r % bound; 923 } 924 } 925 926 #if PCG_HAS_128BIT_OPS 927 inline uint64_t pcg_oneseq_128_xsh_rs_64_random_r(struct pcg_state_128* rng) 928 { 929 pcg_oneseq_128_step_r(rng); 930 return pcg_output_xsh_rs_128_64(rng->state); 931 } 932 #endif 933 934 #if PCG_HAS_128BIT_OPS 935 inline uint64_t 936 pcg_oneseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng, 937 uint64_t bound) 938 { 939 uint64_t threshold = -bound % bound; 940 for (;;) { 941 uint64_t r = pcg_oneseq_128_xsh_rs_64_random_r(rng); 942 if (r >= threshold) 943 return r % bound; 944 } 945 } 946 #endif 947 948 inline uint8_t pcg_unique_16_xsh_rs_8_random_r(struct pcg_state_16* rng) 949 { 950 uint16_t oldstate = rng->state; 951 pcg_unique_16_step_r(rng); 952 return pcg_output_xsh_rs_16_8(oldstate); 953 } 954 955 inline uint8_t pcg_unique_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng, 956 uint8_t bound) 957 { 958 uint8_t threshold = ((uint8_t)(-bound)) % bound; 959 for (;;) { 960 uint8_t r = pcg_unique_16_xsh_rs_8_random_r(rng); 961 if (r >= threshold) 962 return r % bound; 963 } 964 } 965 966 inline uint16_t pcg_unique_32_xsh_rs_16_random_r(struct pcg_state_32* rng) 967 { 968 uint32_t oldstate = rng->state; 969 pcg_unique_32_step_r(rng); 970 return pcg_output_xsh_rs_32_16(oldstate); 971 } 972 973 inline uint16_t pcg_unique_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng, 974 uint16_t bound) 975 { 976 uint16_t threshold = ((uint16_t)(-bound)) % bound; 977 for (;;) { 978 uint16_t r = pcg_unique_32_xsh_rs_16_random_r(rng); 979 if (r >= threshold) 980 return r % bound; 981 } 982 } 983 984 inline uint32_t pcg_unique_64_xsh_rs_32_random_r(struct pcg_state_64* rng) 985 { 986 uint64_t oldstate = rng->state; 987 pcg_unique_64_step_r(rng); 988 return pcg_output_xsh_rs_64_32(oldstate); 989 } 990 991 inline uint32_t pcg_unique_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng, 992 uint32_t bound) 993 { 994 uint32_t threshold = -bound % bound; 995 for (;;) { 996 uint32_t r = pcg_unique_64_xsh_rs_32_random_r(rng); 997 if (r >= threshold) 998 return r % bound; 999 } 1000 } 1001 1002 #if PCG_HAS_128BIT_OPS 1003 inline uint64_t pcg_unique_128_xsh_rs_64_random_r(struct pcg_state_128* rng) 1004 { 1005 pcg_unique_128_step_r(rng); 1006 return pcg_output_xsh_rs_128_64(rng->state); 1007 } 1008 #endif 1009 1010 #if PCG_HAS_128BIT_OPS 1011 inline uint64_t 1012 pcg_unique_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng, 1013 uint64_t bound) 1014 { 1015 uint64_t threshold = -bound % bound; 1016 for (;;) { 1017 uint64_t r = pcg_unique_128_xsh_rs_64_random_r(rng); 1018 if (r >= threshold) 1019 return r % bound; 1020 } 1021 } 1022 #endif 1023 1024 inline uint8_t pcg_setseq_16_xsh_rs_8_random_r(struct pcg_state_setseq_16* rng) 1025 { 1026 uint16_t oldstate = rng->state; 1027 pcg_setseq_16_step_r(rng); 1028 return pcg_output_xsh_rs_16_8(oldstate); 1029 } 1030 1031 inline uint8_t 1032 pcg_setseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_setseq_16* rng, 1033 uint8_t bound) 1034 { 1035 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1036 for (;;) { 1037 uint8_t r = pcg_setseq_16_xsh_rs_8_random_r(rng); 1038 if (r >= threshold) 1039 return r % bound; 1040 } 1041 } 1042 1043 inline uint16_t 1044 pcg_setseq_32_xsh_rs_16_random_r(struct pcg_state_setseq_32* rng) 1045 { 1046 uint32_t oldstate = rng->state; 1047 pcg_setseq_32_step_r(rng); 1048 return pcg_output_xsh_rs_32_16(oldstate); 1049 } 1050 1051 inline uint16_t 1052 pcg_setseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_setseq_32* rng, 1053 uint16_t bound) 1054 { 1055 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1056 for (;;) { 1057 uint16_t r = pcg_setseq_32_xsh_rs_16_random_r(rng); 1058 if (r >= threshold) 1059 return r % bound; 1060 } 1061 } 1062 1063 inline uint32_t 1064 pcg_setseq_64_xsh_rs_32_random_r(struct pcg_state_setseq_64* rng) 1065 { 1066 uint64_t oldstate = rng->state; 1067 pcg_setseq_64_step_r(rng); 1068 return pcg_output_xsh_rs_64_32(oldstate); 1069 } 1070 1071 inline uint32_t 1072 pcg_setseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_setseq_64* rng, 1073 uint32_t bound) 1074 { 1075 uint32_t threshold = -bound % bound; 1076 for (;;) { 1077 uint32_t r = pcg_setseq_64_xsh_rs_32_random_r(rng); 1078 if (r >= threshold) 1079 return r % bound; 1080 } 1081 } 1082 1083 #if PCG_HAS_128BIT_OPS 1084 inline uint64_t 1085 pcg_setseq_128_xsh_rs_64_random_r(struct pcg_state_setseq_128* rng) 1086 { 1087 pcg_setseq_128_step_r(rng); 1088 return pcg_output_xsh_rs_128_64(rng->state); 1089 } 1090 #endif 1091 1092 #if PCG_HAS_128BIT_OPS 1093 inline uint64_t 1094 pcg_setseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_setseq_128* rng, 1095 uint64_t bound) 1096 { 1097 uint64_t threshold = -bound % bound; 1098 for (;;) { 1099 uint64_t r = pcg_setseq_128_xsh_rs_64_random_r(rng); 1100 if (r >= threshold) 1101 return r % bound; 1102 } 1103 } 1104 #endif 1105 1106 inline uint8_t pcg_mcg_16_xsh_rs_8_random_r(struct pcg_state_16* rng) 1107 { 1108 uint16_t oldstate = rng->state; 1109 pcg_mcg_16_step_r(rng); 1110 return pcg_output_xsh_rs_16_8(oldstate); 1111 } 1112 1113 inline uint8_t pcg_mcg_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng, 1114 uint8_t bound) 1115 { 1116 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1117 for (;;) { 1118 uint8_t r = pcg_mcg_16_xsh_rs_8_random_r(rng); 1119 if (r >= threshold) 1120 return r % bound; 1121 } 1122 } 1123 1124 inline uint16_t pcg_mcg_32_xsh_rs_16_random_r(struct pcg_state_32* rng) 1125 { 1126 uint32_t oldstate = rng->state; 1127 pcg_mcg_32_step_r(rng); 1128 return pcg_output_xsh_rs_32_16(oldstate); 1129 } 1130 1131 inline uint16_t pcg_mcg_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng, 1132 uint16_t bound) 1133 { 1134 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1135 for (;;) { 1136 uint16_t r = pcg_mcg_32_xsh_rs_16_random_r(rng); 1137 if (r >= threshold) 1138 return r % bound; 1139 } 1140 } 1141 1142 inline uint32_t pcg_mcg_64_xsh_rs_32_random_r(struct pcg_state_64* rng) 1143 { 1144 uint64_t oldstate = rng->state; 1145 pcg_mcg_64_step_r(rng); 1146 return pcg_output_xsh_rs_64_32(oldstate); 1147 } 1148 1149 inline uint32_t pcg_mcg_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng, 1150 uint32_t bound) 1151 { 1152 uint32_t threshold = -bound % bound; 1153 for (;;) { 1154 uint32_t r = pcg_mcg_64_xsh_rs_32_random_r(rng); 1155 if (r >= threshold) 1156 return r % bound; 1157 } 1158 } 1159 1160 #if PCG_HAS_128BIT_OPS 1161 inline uint64_t pcg_mcg_128_xsh_rs_64_random_r(struct pcg_state_128* rng) 1162 { 1163 pcg_mcg_128_step_r(rng); 1164 return pcg_output_xsh_rs_128_64(rng->state); 1165 } 1166 #endif 1167 1168 #if PCG_HAS_128BIT_OPS 1169 inline uint64_t pcg_mcg_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng, 1170 uint64_t bound) 1171 { 1172 uint64_t threshold = -bound % bound; 1173 for (;;) { 1174 uint64_t r = pcg_mcg_128_xsh_rs_64_random_r(rng); 1175 if (r >= threshold) 1176 return r % bound; 1177 } 1178 } 1179 #endif 1180 1181 /* Generation functions for XSH RR */ 1182 1183 inline uint8_t pcg_oneseq_16_xsh_rr_8_random_r(struct pcg_state_16* rng) 1184 { 1185 uint16_t oldstate = rng->state; 1186 pcg_oneseq_16_step_r(rng); 1187 return pcg_output_xsh_rr_16_8(oldstate); 1188 } 1189 1190 inline uint8_t pcg_oneseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng, 1191 uint8_t bound) 1192 { 1193 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1194 for (;;) { 1195 uint8_t r = pcg_oneseq_16_xsh_rr_8_random_r(rng); 1196 if (r >= threshold) 1197 return r % bound; 1198 } 1199 } 1200 1201 inline uint16_t pcg_oneseq_32_xsh_rr_16_random_r(struct pcg_state_32* rng) 1202 { 1203 uint32_t oldstate = rng->state; 1204 pcg_oneseq_32_step_r(rng); 1205 return pcg_output_xsh_rr_32_16(oldstate); 1206 } 1207 1208 inline uint16_t pcg_oneseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng, 1209 uint16_t bound) 1210 { 1211 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1212 for (;;) { 1213 uint16_t r = pcg_oneseq_32_xsh_rr_16_random_r(rng); 1214 if (r >= threshold) 1215 return r % bound; 1216 } 1217 } 1218 1219 inline uint32_t pcg_oneseq_64_xsh_rr_32_random_r(struct pcg_state_64* rng) 1220 { 1221 uint64_t oldstate = rng->state; 1222 pcg_oneseq_64_step_r(rng); 1223 return pcg_output_xsh_rr_64_32(oldstate); 1224 } 1225 1226 inline uint32_t pcg_oneseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng, 1227 uint32_t bound) 1228 { 1229 uint32_t threshold = -bound % bound; 1230 for (;;) { 1231 uint32_t r = pcg_oneseq_64_xsh_rr_32_random_r(rng); 1232 if (r >= threshold) 1233 return r % bound; 1234 } 1235 } 1236 1237 #if PCG_HAS_128BIT_OPS 1238 inline uint64_t pcg_oneseq_128_xsh_rr_64_random_r(struct pcg_state_128* rng) 1239 { 1240 pcg_oneseq_128_step_r(rng); 1241 return pcg_output_xsh_rr_128_64(rng->state); 1242 } 1243 #endif 1244 1245 #if PCG_HAS_128BIT_OPS 1246 inline uint64_t 1247 pcg_oneseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng, 1248 uint64_t bound) 1249 { 1250 uint64_t threshold = -bound % bound; 1251 for (;;) { 1252 uint64_t r = pcg_oneseq_128_xsh_rr_64_random_r(rng); 1253 if (r >= threshold) 1254 return r % bound; 1255 } 1256 } 1257 #endif 1258 1259 inline uint8_t pcg_unique_16_xsh_rr_8_random_r(struct pcg_state_16* rng) 1260 { 1261 uint16_t oldstate = rng->state; 1262 pcg_unique_16_step_r(rng); 1263 return pcg_output_xsh_rr_16_8(oldstate); 1264 } 1265 1266 inline uint8_t pcg_unique_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng, 1267 uint8_t bound) 1268 { 1269 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1270 for (;;) { 1271 uint8_t r = pcg_unique_16_xsh_rr_8_random_r(rng); 1272 if (r >= threshold) 1273 return r % bound; 1274 } 1275 } 1276 1277 inline uint16_t pcg_unique_32_xsh_rr_16_random_r(struct pcg_state_32* rng) 1278 { 1279 uint32_t oldstate = rng->state; 1280 pcg_unique_32_step_r(rng); 1281 return pcg_output_xsh_rr_32_16(oldstate); 1282 } 1283 1284 inline uint16_t pcg_unique_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng, 1285 uint16_t bound) 1286 { 1287 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1288 for (;;) { 1289 uint16_t r = pcg_unique_32_xsh_rr_16_random_r(rng); 1290 if (r >= threshold) 1291 return r % bound; 1292 } 1293 } 1294 1295 inline uint32_t pcg_unique_64_xsh_rr_32_random_r(struct pcg_state_64* rng) 1296 { 1297 uint64_t oldstate = rng->state; 1298 pcg_unique_64_step_r(rng); 1299 return pcg_output_xsh_rr_64_32(oldstate); 1300 } 1301 1302 inline uint32_t pcg_unique_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng, 1303 uint32_t bound) 1304 { 1305 uint32_t threshold = -bound % bound; 1306 for (;;) { 1307 uint32_t r = pcg_unique_64_xsh_rr_32_random_r(rng); 1308 if (r >= threshold) 1309 return r % bound; 1310 } 1311 } 1312 1313 #if PCG_HAS_128BIT_OPS 1314 inline uint64_t pcg_unique_128_xsh_rr_64_random_r(struct pcg_state_128* rng) 1315 { 1316 pcg_unique_128_step_r(rng); 1317 return pcg_output_xsh_rr_128_64(rng->state); 1318 } 1319 #endif 1320 1321 #if PCG_HAS_128BIT_OPS 1322 inline uint64_t 1323 pcg_unique_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng, 1324 uint64_t bound) 1325 { 1326 uint64_t threshold = -bound % bound; 1327 for (;;) { 1328 uint64_t r = pcg_unique_128_xsh_rr_64_random_r(rng); 1329 if (r >= threshold) 1330 return r % bound; 1331 } 1332 } 1333 #endif 1334 1335 inline uint8_t pcg_setseq_16_xsh_rr_8_random_r(struct pcg_state_setseq_16* rng) 1336 { 1337 uint16_t oldstate = rng->state; 1338 pcg_setseq_16_step_r(rng); 1339 return pcg_output_xsh_rr_16_8(oldstate); 1340 } 1341 1342 inline uint8_t 1343 pcg_setseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_setseq_16* rng, 1344 uint8_t bound) 1345 { 1346 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1347 for (;;) { 1348 uint8_t r = pcg_setseq_16_xsh_rr_8_random_r(rng); 1349 if (r >= threshold) 1350 return r % bound; 1351 } 1352 } 1353 1354 inline uint16_t 1355 pcg_setseq_32_xsh_rr_16_random_r(struct pcg_state_setseq_32* rng) 1356 { 1357 uint32_t oldstate = rng->state; 1358 pcg_setseq_32_step_r(rng); 1359 return pcg_output_xsh_rr_32_16(oldstate); 1360 } 1361 1362 inline uint16_t 1363 pcg_setseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_setseq_32* rng, 1364 uint16_t bound) 1365 { 1366 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1367 for (;;) { 1368 uint16_t r = pcg_setseq_32_xsh_rr_16_random_r(rng); 1369 if (r >= threshold) 1370 return r % bound; 1371 } 1372 } 1373 1374 inline uint32_t 1375 pcg_setseq_64_xsh_rr_32_random_r(struct pcg_state_setseq_64* rng) 1376 { 1377 uint64_t oldstate = rng->state; 1378 pcg_setseq_64_step_r(rng); 1379 return pcg_output_xsh_rr_64_32(oldstate); 1380 } 1381 1382 inline uint32_t 1383 pcg_setseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_setseq_64* rng, 1384 uint32_t bound) 1385 { 1386 uint32_t threshold = -bound % bound; 1387 for (;;) { 1388 uint32_t r = pcg_setseq_64_xsh_rr_32_random_r(rng); 1389 if (r >= threshold) 1390 return r % bound; 1391 } 1392 } 1393 1394 #if PCG_HAS_128BIT_OPS 1395 inline uint64_t 1396 pcg_setseq_128_xsh_rr_64_random_r(struct pcg_state_setseq_128* rng) 1397 { 1398 pcg_setseq_128_step_r(rng); 1399 return pcg_output_xsh_rr_128_64(rng->state); 1400 } 1401 #endif 1402 1403 #if PCG_HAS_128BIT_OPS 1404 inline uint64_t 1405 pcg_setseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_setseq_128* rng, 1406 uint64_t bound) 1407 { 1408 uint64_t threshold = -bound % bound; 1409 for (;;) { 1410 uint64_t r = pcg_setseq_128_xsh_rr_64_random_r(rng); 1411 if (r >= threshold) 1412 return r % bound; 1413 } 1414 } 1415 #endif 1416 1417 inline uint8_t pcg_mcg_16_xsh_rr_8_random_r(struct pcg_state_16* rng) 1418 { 1419 uint16_t oldstate = rng->state; 1420 pcg_mcg_16_step_r(rng); 1421 return pcg_output_xsh_rr_16_8(oldstate); 1422 } 1423 1424 inline uint8_t pcg_mcg_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng, 1425 uint8_t bound) 1426 { 1427 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1428 for (;;) { 1429 uint8_t r = pcg_mcg_16_xsh_rr_8_random_r(rng); 1430 if (r >= threshold) 1431 return r % bound; 1432 } 1433 } 1434 1435 inline uint16_t pcg_mcg_32_xsh_rr_16_random_r(struct pcg_state_32* rng) 1436 { 1437 uint32_t oldstate = rng->state; 1438 pcg_mcg_32_step_r(rng); 1439 return pcg_output_xsh_rr_32_16(oldstate); 1440 } 1441 1442 inline uint16_t pcg_mcg_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng, 1443 uint16_t bound) 1444 { 1445 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1446 for (;;) { 1447 uint16_t r = pcg_mcg_32_xsh_rr_16_random_r(rng); 1448 if (r >= threshold) 1449 return r % bound; 1450 } 1451 } 1452 1453 inline uint32_t pcg_mcg_64_xsh_rr_32_random_r(struct pcg_state_64* rng) 1454 { 1455 uint64_t oldstate = rng->state; 1456 pcg_mcg_64_step_r(rng); 1457 return pcg_output_xsh_rr_64_32(oldstate); 1458 } 1459 1460 inline uint32_t pcg_mcg_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng, 1461 uint32_t bound) 1462 { 1463 uint32_t threshold = -bound % bound; 1464 for (;;) { 1465 uint32_t r = pcg_mcg_64_xsh_rr_32_random_r(rng); 1466 if (r >= threshold) 1467 return r % bound; 1468 } 1469 } 1470 1471 #if PCG_HAS_128BIT_OPS 1472 inline uint64_t pcg_mcg_128_xsh_rr_64_random_r(struct pcg_state_128* rng) 1473 { 1474 pcg_mcg_128_step_r(rng); 1475 return pcg_output_xsh_rr_128_64(rng->state); 1476 } 1477 #endif 1478 1479 #if PCG_HAS_128BIT_OPS 1480 inline uint64_t pcg_mcg_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng, 1481 uint64_t bound) 1482 { 1483 uint64_t threshold = -bound % bound; 1484 for (;;) { 1485 uint64_t r = pcg_mcg_128_xsh_rr_64_random_r(rng); 1486 if (r >= threshold) 1487 return r % bound; 1488 } 1489 } 1490 #endif 1491 1492 /* Generation functions for RXS M XS (no MCG versions because they 1493 * don't make sense when you want to use the entire state) 1494 */ 1495 1496 inline uint8_t pcg_oneseq_8_rxs_m_xs_8_random_r(struct pcg_state_8* rng) 1497 { 1498 uint8_t oldstate = rng->state; 1499 pcg_oneseq_8_step_r(rng); 1500 return pcg_output_rxs_m_xs_8_8(oldstate); 1501 } 1502 1503 inline uint8_t pcg_oneseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_8* rng, 1504 uint8_t bound) 1505 { 1506 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1507 for (;;) { 1508 uint8_t r = pcg_oneseq_8_rxs_m_xs_8_random_r(rng); 1509 if (r >= threshold) 1510 return r % bound; 1511 } 1512 } 1513 1514 inline uint16_t pcg_oneseq_16_rxs_m_xs_16_random_r(struct pcg_state_16* rng) 1515 { 1516 uint16_t oldstate = rng->state; 1517 pcg_oneseq_16_step_r(rng); 1518 return pcg_output_rxs_m_xs_16_16(oldstate); 1519 } 1520 1521 inline uint16_t 1522 pcg_oneseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng, 1523 uint16_t bound) 1524 { 1525 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1526 for (;;) { 1527 uint16_t r = pcg_oneseq_16_rxs_m_xs_16_random_r(rng); 1528 if (r >= threshold) 1529 return r % bound; 1530 } 1531 } 1532 1533 inline uint32_t pcg_oneseq_32_rxs_m_xs_32_random_r(struct pcg_state_32* rng) 1534 { 1535 uint32_t oldstate = rng->state; 1536 pcg_oneseq_32_step_r(rng); 1537 return pcg_output_rxs_m_xs_32_32(oldstate); 1538 } 1539 1540 inline uint32_t 1541 pcg_oneseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32* rng, 1542 uint32_t bound) 1543 { 1544 uint32_t threshold = -bound % bound; 1545 for (;;) { 1546 uint32_t r = pcg_oneseq_32_rxs_m_xs_32_random_r(rng); 1547 if (r >= threshold) 1548 return r % bound; 1549 } 1550 } 1551 1552 inline uint64_t pcg_oneseq_64_rxs_m_xs_64_random_r(struct pcg_state_64* rng) 1553 { 1554 uint64_t oldstate = rng->state; 1555 pcg_oneseq_64_step_r(rng); 1556 return pcg_output_rxs_m_xs_64_64(oldstate); 1557 } 1558 1559 inline uint64_t 1560 pcg_oneseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64* rng, 1561 uint64_t bound) 1562 { 1563 uint64_t threshold = -bound % bound; 1564 for (;;) { 1565 uint64_t r = pcg_oneseq_64_rxs_m_xs_64_random_r(rng); 1566 if (r >= threshold) 1567 return r % bound; 1568 } 1569 } 1570 1571 #if PCG_HAS_128BIT_OPS 1572 inline pcg128_t pcg_oneseq_128_rxs_m_xs_128_random_r(struct pcg_state_128* rng) 1573 { 1574 pcg_oneseq_128_step_r(rng); 1575 return pcg_output_rxs_m_xs_128_128(rng->state); 1576 } 1577 #endif 1578 1579 #if PCG_HAS_128BIT_OPS 1580 inline pcg128_t 1581 pcg_oneseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128* rng, 1582 pcg128_t bound) 1583 { 1584 pcg128_t threshold = -bound % bound; 1585 for (;;) { 1586 pcg128_t r = pcg_oneseq_128_rxs_m_xs_128_random_r(rng); 1587 if (r >= threshold) 1588 return r % bound; 1589 } 1590 } 1591 #endif 1592 1593 inline uint16_t pcg_unique_16_rxs_m_xs_16_random_r(struct pcg_state_16* rng) 1594 { 1595 uint16_t oldstate = rng->state; 1596 pcg_unique_16_step_r(rng); 1597 return pcg_output_rxs_m_xs_16_16(oldstate); 1598 } 1599 1600 inline uint16_t 1601 pcg_unique_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng, 1602 uint16_t bound) 1603 { 1604 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1605 for (;;) { 1606 uint16_t r = pcg_unique_16_rxs_m_xs_16_random_r(rng); 1607 if (r >= threshold) 1608 return r % bound; 1609 } 1610 } 1611 1612 inline uint32_t pcg_unique_32_rxs_m_xs_32_random_r(struct pcg_state_32* rng) 1613 { 1614 uint32_t oldstate = rng->state; 1615 pcg_unique_32_step_r(rng); 1616 return pcg_output_rxs_m_xs_32_32(oldstate); 1617 } 1618 1619 inline uint32_t 1620 pcg_unique_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32* rng, 1621 uint32_t bound) 1622 { 1623 uint32_t threshold = -bound % bound; 1624 for (;;) { 1625 uint32_t r = pcg_unique_32_rxs_m_xs_32_random_r(rng); 1626 if (r >= threshold) 1627 return r % bound; 1628 } 1629 } 1630 1631 inline uint64_t pcg_unique_64_rxs_m_xs_64_random_r(struct pcg_state_64* rng) 1632 { 1633 uint64_t oldstate = rng->state; 1634 pcg_unique_64_step_r(rng); 1635 return pcg_output_rxs_m_xs_64_64(oldstate); 1636 } 1637 1638 inline uint64_t 1639 pcg_unique_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64* rng, 1640 uint64_t bound) 1641 { 1642 uint64_t threshold = -bound % bound; 1643 for (;;) { 1644 uint64_t r = pcg_unique_64_rxs_m_xs_64_random_r(rng); 1645 if (r >= threshold) 1646 return r % bound; 1647 } 1648 } 1649 1650 #if PCG_HAS_128BIT_OPS 1651 inline pcg128_t pcg_unique_128_rxs_m_xs_128_random_r(struct pcg_state_128* rng) 1652 { 1653 pcg_unique_128_step_r(rng); 1654 return pcg_output_rxs_m_xs_128_128(rng->state); 1655 } 1656 #endif 1657 1658 #if PCG_HAS_128BIT_OPS 1659 inline pcg128_t 1660 pcg_unique_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128* rng, 1661 pcg128_t bound) 1662 { 1663 pcg128_t threshold = -bound % bound; 1664 for (;;) { 1665 pcg128_t r = pcg_unique_128_rxs_m_xs_128_random_r(rng); 1666 if (r >= threshold) 1667 return r % bound; 1668 } 1669 } 1670 #endif 1671 1672 inline uint8_t pcg_setseq_8_rxs_m_xs_8_random_r(struct pcg_state_setseq_8* rng) 1673 { 1674 uint8_t oldstate = rng->state; 1675 pcg_setseq_8_step_r(rng); 1676 return pcg_output_rxs_m_xs_8_8(oldstate); 1677 } 1678 1679 inline uint8_t 1680 pcg_setseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_setseq_8* rng, 1681 uint8_t bound) 1682 { 1683 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1684 for (;;) { 1685 uint8_t r = pcg_setseq_8_rxs_m_xs_8_random_r(rng); 1686 if (r >= threshold) 1687 return r % bound; 1688 } 1689 } 1690 1691 inline uint16_t 1692 pcg_setseq_16_rxs_m_xs_16_random_r(struct pcg_state_setseq_16* rng) 1693 { 1694 uint16_t oldstate = rng->state; 1695 pcg_setseq_16_step_r(rng); 1696 return pcg_output_rxs_m_xs_16_16(oldstate); 1697 } 1698 1699 inline uint16_t 1700 pcg_setseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_setseq_16* rng, 1701 uint16_t bound) 1702 { 1703 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1704 for (;;) { 1705 uint16_t r = pcg_setseq_16_rxs_m_xs_16_random_r(rng); 1706 if (r >= threshold) 1707 return r % bound; 1708 } 1709 } 1710 1711 inline uint32_t 1712 pcg_setseq_32_rxs_m_xs_32_random_r(struct pcg_state_setseq_32* rng) 1713 { 1714 uint32_t oldstate = rng->state; 1715 pcg_setseq_32_step_r(rng); 1716 return pcg_output_rxs_m_xs_32_32(oldstate); 1717 } 1718 1719 inline uint32_t 1720 pcg_setseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_setseq_32* rng, 1721 uint32_t bound) 1722 { 1723 uint32_t threshold = -bound % bound; 1724 for (;;) { 1725 uint32_t r = pcg_setseq_32_rxs_m_xs_32_random_r(rng); 1726 if (r >= threshold) 1727 return r % bound; 1728 } 1729 } 1730 1731 inline uint64_t 1732 pcg_setseq_64_rxs_m_xs_64_random_r(struct pcg_state_setseq_64* rng) 1733 { 1734 uint64_t oldstate = rng->state; 1735 pcg_setseq_64_step_r(rng); 1736 return pcg_output_rxs_m_xs_64_64(oldstate); 1737 } 1738 1739 inline uint64_t 1740 pcg_setseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_setseq_64* rng, 1741 uint64_t bound) 1742 { 1743 uint64_t threshold = -bound % bound; 1744 for (;;) { 1745 uint64_t r = pcg_setseq_64_rxs_m_xs_64_random_r(rng); 1746 if (r >= threshold) 1747 return r % bound; 1748 } 1749 } 1750 1751 #if PCG_HAS_128BIT_OPS 1752 inline pcg128_t 1753 pcg_setseq_128_rxs_m_xs_128_random_r(struct pcg_state_setseq_128* rng) 1754 { 1755 pcg_setseq_128_step_r(rng); 1756 return pcg_output_rxs_m_xs_128_128(rng->state); 1757 } 1758 #endif 1759 1760 #if PCG_HAS_128BIT_OPS 1761 inline pcg128_t 1762 pcg_setseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_setseq_128* rng, 1763 pcg128_t bound) 1764 { 1765 pcg128_t threshold = -bound % bound; 1766 for (;;) { 1767 pcg128_t r = pcg_setseq_128_rxs_m_xs_128_random_r(rng); 1768 if (r >= threshold) 1769 return r % bound; 1770 } 1771 } 1772 #endif 1773 1774 /* Generation functions for RXS M */ 1775 1776 inline uint8_t pcg_oneseq_16_rxs_m_8_random_r(struct pcg_state_16* rng) 1777 { 1778 uint16_t oldstate = rng->state; 1779 pcg_oneseq_16_step_r(rng); 1780 return pcg_output_rxs_m_16_8(oldstate); 1781 } 1782 1783 inline uint8_t pcg_oneseq_16_rxs_m_8_boundedrand_r(struct pcg_state_16* rng, 1784 uint8_t bound) 1785 { 1786 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1787 for (;;) { 1788 uint8_t r = pcg_oneseq_16_rxs_m_8_random_r(rng); 1789 if (r >= threshold) 1790 return r % bound; 1791 } 1792 } 1793 1794 inline uint16_t pcg_oneseq_32_rxs_m_16_random_r(struct pcg_state_32* rng) 1795 { 1796 uint32_t oldstate = rng->state; 1797 pcg_oneseq_32_step_r(rng); 1798 return pcg_output_rxs_m_32_16(oldstate); 1799 } 1800 1801 inline uint16_t pcg_oneseq_32_rxs_m_16_boundedrand_r(struct pcg_state_32* rng, 1802 uint16_t bound) 1803 { 1804 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1805 for (;;) { 1806 uint16_t r = pcg_oneseq_32_rxs_m_16_random_r(rng); 1807 if (r >= threshold) 1808 return r % bound; 1809 } 1810 } 1811 1812 inline uint32_t pcg_oneseq_64_rxs_m_32_random_r(struct pcg_state_64* rng) 1813 { 1814 uint64_t oldstate = rng->state; 1815 pcg_oneseq_64_step_r(rng); 1816 return pcg_output_rxs_m_64_32(oldstate); 1817 } 1818 1819 inline uint32_t pcg_oneseq_64_rxs_m_32_boundedrand_r(struct pcg_state_64* rng, 1820 uint32_t bound) 1821 { 1822 uint32_t threshold = -bound % bound; 1823 for (;;) { 1824 uint32_t r = pcg_oneseq_64_rxs_m_32_random_r(rng); 1825 if (r >= threshold) 1826 return r % bound; 1827 } 1828 } 1829 1830 #if PCG_HAS_128BIT_OPS 1831 inline uint64_t pcg_oneseq_128_rxs_m_64_random_r(struct pcg_state_128* rng) 1832 { 1833 pcg_oneseq_128_step_r(rng); 1834 return pcg_output_rxs_m_128_64(rng->state); 1835 } 1836 #endif 1837 1838 #if PCG_HAS_128BIT_OPS 1839 inline uint64_t pcg_oneseq_128_rxs_m_64_boundedrand_r(struct pcg_state_128* rng, 1840 uint64_t bound) 1841 { 1842 uint64_t threshold = -bound % bound; 1843 for (;;) { 1844 uint64_t r = pcg_oneseq_128_rxs_m_64_random_r(rng); 1845 if (r >= threshold) 1846 return r % bound; 1847 } 1848 } 1849 #endif 1850 1851 inline uint8_t pcg_unique_16_rxs_m_8_random_r(struct pcg_state_16* rng) 1852 { 1853 uint16_t oldstate = rng->state; 1854 pcg_unique_16_step_r(rng); 1855 return pcg_output_rxs_m_16_8(oldstate); 1856 } 1857 1858 inline uint8_t pcg_unique_16_rxs_m_8_boundedrand_r(struct pcg_state_16* rng, 1859 uint8_t bound) 1860 { 1861 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1862 for (;;) { 1863 uint8_t r = pcg_unique_16_rxs_m_8_random_r(rng); 1864 if (r >= threshold) 1865 return r % bound; 1866 } 1867 } 1868 1869 inline uint16_t pcg_unique_32_rxs_m_16_random_r(struct pcg_state_32* rng) 1870 { 1871 uint32_t oldstate = rng->state; 1872 pcg_unique_32_step_r(rng); 1873 return pcg_output_rxs_m_32_16(oldstate); 1874 } 1875 1876 inline uint16_t pcg_unique_32_rxs_m_16_boundedrand_r(struct pcg_state_32* rng, 1877 uint16_t bound) 1878 { 1879 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1880 for (;;) { 1881 uint16_t r = pcg_unique_32_rxs_m_16_random_r(rng); 1882 if (r >= threshold) 1883 return r % bound; 1884 } 1885 } 1886 1887 inline uint32_t pcg_unique_64_rxs_m_32_random_r(struct pcg_state_64* rng) 1888 { 1889 uint64_t oldstate = rng->state; 1890 pcg_unique_64_step_r(rng); 1891 return pcg_output_rxs_m_64_32(oldstate); 1892 } 1893 1894 inline uint32_t pcg_unique_64_rxs_m_32_boundedrand_r(struct pcg_state_64* rng, 1895 uint32_t bound) 1896 { 1897 uint32_t threshold = -bound % bound; 1898 for (;;) { 1899 uint32_t r = pcg_unique_64_rxs_m_32_random_r(rng); 1900 if (r >= threshold) 1901 return r % bound; 1902 } 1903 } 1904 1905 #if PCG_HAS_128BIT_OPS 1906 inline uint64_t pcg_unique_128_rxs_m_64_random_r(struct pcg_state_128* rng) 1907 { 1908 pcg_unique_128_step_r(rng); 1909 return pcg_output_rxs_m_128_64(rng->state); 1910 } 1911 #endif 1912 1913 #if PCG_HAS_128BIT_OPS 1914 inline uint64_t pcg_unique_128_rxs_m_64_boundedrand_r(struct pcg_state_128* rng, 1915 uint64_t bound) 1916 { 1917 uint64_t threshold = -bound % bound; 1918 for (;;) { 1919 uint64_t r = pcg_unique_128_rxs_m_64_random_r(rng); 1920 if (r >= threshold) 1921 return r % bound; 1922 } 1923 } 1924 #endif 1925 1926 inline uint8_t pcg_setseq_16_rxs_m_8_random_r(struct pcg_state_setseq_16* rng) 1927 { 1928 uint16_t oldstate = rng->state; 1929 pcg_setseq_16_step_r(rng); 1930 return pcg_output_rxs_m_16_8(oldstate); 1931 } 1932 1933 inline uint8_t 1934 pcg_setseq_16_rxs_m_8_boundedrand_r(struct pcg_state_setseq_16* rng, 1935 uint8_t bound) 1936 { 1937 uint8_t threshold = ((uint8_t)(-bound)) % bound; 1938 for (;;) { 1939 uint8_t r = pcg_setseq_16_rxs_m_8_random_r(rng); 1940 if (r >= threshold) 1941 return r % bound; 1942 } 1943 } 1944 1945 inline uint16_t pcg_setseq_32_rxs_m_16_random_r(struct pcg_state_setseq_32* rng) 1946 { 1947 uint32_t oldstate = rng->state; 1948 pcg_setseq_32_step_r(rng); 1949 return pcg_output_rxs_m_32_16(oldstate); 1950 } 1951 1952 inline uint16_t 1953 pcg_setseq_32_rxs_m_16_boundedrand_r(struct pcg_state_setseq_32* rng, 1954 uint16_t bound) 1955 { 1956 uint16_t threshold = ((uint16_t)(-bound)) % bound; 1957 for (;;) { 1958 uint16_t r = pcg_setseq_32_rxs_m_16_random_r(rng); 1959 if (r >= threshold) 1960 return r % bound; 1961 } 1962 } 1963 1964 inline uint32_t pcg_setseq_64_rxs_m_32_random_r(struct pcg_state_setseq_64* rng) 1965 { 1966 uint64_t oldstate = rng->state; 1967 pcg_setseq_64_step_r(rng); 1968 return pcg_output_rxs_m_64_32(oldstate); 1969 } 1970 1971 inline uint32_t 1972 pcg_setseq_64_rxs_m_32_boundedrand_r(struct pcg_state_setseq_64* rng, 1973 uint32_t bound) 1974 { 1975 uint32_t threshold = -bound % bound; 1976 for (;;) { 1977 uint32_t r = pcg_setseq_64_rxs_m_32_random_r(rng); 1978 if (r >= threshold) 1979 return r % bound; 1980 } 1981 } 1982 1983 #if PCG_HAS_128BIT_OPS 1984 inline uint64_t 1985 pcg_setseq_128_rxs_m_64_random_r(struct pcg_state_setseq_128* rng) 1986 { 1987 pcg_setseq_128_step_r(rng); 1988 return pcg_output_rxs_m_128_64(rng->state); 1989 } 1990 #endif 1991 1992 #if PCG_HAS_128BIT_OPS 1993 inline uint64_t 1994 pcg_setseq_128_rxs_m_64_boundedrand_r(struct pcg_state_setseq_128* rng, 1995 uint64_t bound) 1996 { 1997 uint64_t threshold = -bound % bound; 1998 for (;;) { 1999 uint64_t r = pcg_setseq_128_rxs_m_64_random_r(rng); 2000 if (r >= threshold) 2001 return r % bound; 2002 } 2003 } 2004 #endif 2005 2006 inline uint8_t pcg_mcg_16_rxs_m_8_random_r(struct pcg_state_16* rng) 2007 { 2008 uint16_t oldstate = rng->state; 2009 pcg_mcg_16_step_r(rng); 2010 return pcg_output_rxs_m_16_8(oldstate); 2011 } 2012 2013 inline uint8_t pcg_mcg_16_rxs_m_8_boundedrand_r(struct pcg_state_16* rng, 2014 uint8_t bound) 2015 { 2016 uint8_t threshold = ((uint8_t)(-bound)) % bound; 2017 for (;;) { 2018 uint8_t r = pcg_mcg_16_rxs_m_8_random_r(rng); 2019 if (r >= threshold) 2020 return r % bound; 2021 } 2022 } 2023 2024 inline uint16_t pcg_mcg_32_rxs_m_16_random_r(struct pcg_state_32* rng) 2025 { 2026 uint32_t oldstate = rng->state; 2027 pcg_mcg_32_step_r(rng); 2028 return pcg_output_rxs_m_32_16(oldstate); 2029 } 2030 2031 inline uint16_t pcg_mcg_32_rxs_m_16_boundedrand_r(struct pcg_state_32* rng, 2032 uint16_t bound) 2033 { 2034 uint16_t threshold = ((uint16_t)(-bound)) % bound; 2035 for (;;) { 2036 uint16_t r = pcg_mcg_32_rxs_m_16_random_r(rng); 2037 if (r >= threshold) 2038 return r % bound; 2039 } 2040 } 2041 2042 inline uint32_t pcg_mcg_64_rxs_m_32_random_r(struct pcg_state_64* rng) 2043 { 2044 uint64_t oldstate = rng->state; 2045 pcg_mcg_64_step_r(rng); 2046 return pcg_output_rxs_m_64_32(oldstate); 2047 } 2048 2049 inline uint32_t pcg_mcg_64_rxs_m_32_boundedrand_r(struct pcg_state_64* rng, 2050 uint32_t bound) 2051 { 2052 uint32_t threshold = -bound % bound; 2053 for (;;) { 2054 uint32_t r = pcg_mcg_64_rxs_m_32_random_r(rng); 2055 if (r >= threshold) 2056 return r % bound; 2057 } 2058 } 2059 2060 #if PCG_HAS_128BIT_OPS 2061 inline uint64_t pcg_mcg_128_rxs_m_64_random_r(struct pcg_state_128* rng) 2062 { 2063 pcg_mcg_128_step_r(rng); 2064 return pcg_output_rxs_m_128_64(rng->state); 2065 } 2066 #endif 2067 2068 #if PCG_HAS_128BIT_OPS 2069 inline uint64_t pcg_mcg_128_rxs_m_64_boundedrand_r(struct pcg_state_128* rng, 2070 uint64_t bound) 2071 { 2072 uint64_t threshold = -bound % bound; 2073 for (;;) { 2074 uint64_t r = pcg_mcg_128_rxs_m_64_random_r(rng); 2075 if (r >= threshold) 2076 return r % bound; 2077 } 2078 } 2079 #endif 2080 2081 /* Generation functions for XSL RR (only defined for "large" types) */ 2082 2083 inline uint32_t pcg_oneseq_64_xsl_rr_32_random_r(struct pcg_state_64* rng) 2084 { 2085 uint64_t oldstate = rng->state; 2086 pcg_oneseq_64_step_r(rng); 2087 return pcg_output_xsl_rr_64_32(oldstate); 2088 } 2089 2090 inline uint32_t pcg_oneseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng, 2091 uint32_t bound) 2092 { 2093 uint32_t threshold = -bound % bound; 2094 for (;;) { 2095 uint32_t r = pcg_oneseq_64_xsl_rr_32_random_r(rng); 2096 if (r >= threshold) 2097 return r % bound; 2098 } 2099 } 2100 2101 #if PCG_HAS_128BIT_OPS 2102 inline uint64_t pcg_oneseq_128_xsl_rr_64_random_r(struct pcg_state_128* rng) 2103 { 2104 pcg_oneseq_128_step_r(rng); 2105 return pcg_output_xsl_rr_128_64(rng->state); 2106 } 2107 #endif 2108 2109 #if PCG_HAS_128BIT_OPS 2110 inline uint64_t 2111 pcg_oneseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng, 2112 uint64_t bound) 2113 { 2114 uint64_t threshold = -bound % bound; 2115 for (;;) { 2116 uint64_t r = pcg_oneseq_128_xsl_rr_64_random_r(rng); 2117 if (r >= threshold) 2118 return r % bound; 2119 } 2120 } 2121 #endif 2122 2123 inline uint32_t pcg_unique_64_xsl_rr_32_random_r(struct pcg_state_64* rng) 2124 { 2125 uint64_t oldstate = rng->state; 2126 pcg_unique_64_step_r(rng); 2127 return pcg_output_xsl_rr_64_32(oldstate); 2128 } 2129 2130 inline uint32_t pcg_unique_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng, 2131 uint32_t bound) 2132 { 2133 uint32_t threshold = -bound % bound; 2134 for (;;) { 2135 uint32_t r = pcg_unique_64_xsl_rr_32_random_r(rng); 2136 if (r >= threshold) 2137 return r % bound; 2138 } 2139 } 2140 2141 #if PCG_HAS_128BIT_OPS 2142 inline uint64_t pcg_unique_128_xsl_rr_64_random_r(struct pcg_state_128* rng) 2143 { 2144 pcg_unique_128_step_r(rng); 2145 return pcg_output_xsl_rr_128_64(rng->state); 2146 } 2147 #endif 2148 2149 #if PCG_HAS_128BIT_OPS 2150 inline uint64_t 2151 pcg_unique_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng, 2152 uint64_t bound) 2153 { 2154 uint64_t threshold = -bound % bound; 2155 for (;;) { 2156 uint64_t r = pcg_unique_128_xsl_rr_64_random_r(rng); 2157 if (r >= threshold) 2158 return r % bound; 2159 } 2160 } 2161 #endif 2162 2163 inline uint32_t 2164 pcg_setseq_64_xsl_rr_32_random_r(struct pcg_state_setseq_64* rng) 2165 { 2166 uint64_t oldstate = rng->state; 2167 pcg_setseq_64_step_r(rng); 2168 return pcg_output_xsl_rr_64_32(oldstate); 2169 } 2170 2171 inline uint32_t 2172 pcg_setseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_setseq_64* rng, 2173 uint32_t bound) 2174 { 2175 uint32_t threshold = -bound % bound; 2176 for (;;) { 2177 uint32_t r = pcg_setseq_64_xsl_rr_32_random_r(rng); 2178 if (r >= threshold) 2179 return r % bound; 2180 } 2181 } 2182 2183 #if PCG_HAS_128BIT_OPS 2184 inline uint64_t 2185 pcg_setseq_128_xsl_rr_64_random_r(struct pcg_state_setseq_128* rng) 2186 { 2187 pcg_setseq_128_step_r(rng); 2188 return pcg_output_xsl_rr_128_64(rng->state); 2189 } 2190 #endif 2191 2192 #if PCG_HAS_128BIT_OPS 2193 inline uint64_t 2194 pcg_setseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_setseq_128* rng, 2195 uint64_t bound) 2196 { 2197 uint64_t threshold = -bound % bound; 2198 for (;;) { 2199 uint64_t r = pcg_setseq_128_xsl_rr_64_random_r(rng); 2200 if (r >= threshold) 2201 return r % bound; 2202 } 2203 } 2204 #endif 2205 2206 inline uint32_t pcg_mcg_64_xsl_rr_32_random_r(struct pcg_state_64* rng) 2207 { 2208 uint64_t oldstate = rng->state; 2209 pcg_mcg_64_step_r(rng); 2210 return pcg_output_xsl_rr_64_32(oldstate); 2211 } 2212 2213 inline uint32_t pcg_mcg_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng, 2214 uint32_t bound) 2215 { 2216 uint32_t threshold = -bound % bound; 2217 for (;;) { 2218 uint32_t r = pcg_mcg_64_xsl_rr_32_random_r(rng); 2219 if (r >= threshold) 2220 return r % bound; 2221 } 2222 } 2223 2224 #if PCG_HAS_128BIT_OPS 2225 inline uint64_t pcg_mcg_128_xsl_rr_64_random_r(struct pcg_state_128* rng) 2226 { 2227 pcg_mcg_128_step_r(rng); 2228 return pcg_output_xsl_rr_128_64(rng->state); 2229 } 2230 #endif 2231 2232 #if PCG_HAS_128BIT_OPS 2233 inline uint64_t pcg_mcg_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng, 2234 uint64_t bound) 2235 { 2236 uint64_t threshold = -bound % bound; 2237 for (;;) { 2238 uint64_t r = pcg_mcg_128_xsl_rr_64_random_r(rng); 2239 if (r >= threshold) 2240 return r % bound; 2241 } 2242 } 2243 #endif 2244 2245 /* Generation functions for XSL RR RR (only defined for "large" types) */ 2246 2247 inline uint64_t pcg_oneseq_64_xsl_rr_rr_64_random_r(struct pcg_state_64* rng) 2248 { 2249 uint64_t oldstate = rng->state; 2250 pcg_oneseq_64_step_r(rng); 2251 return pcg_output_xsl_rr_rr_64_64(oldstate); 2252 } 2253 2254 inline uint64_t 2255 pcg_oneseq_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_64* rng, 2256 uint64_t bound) 2257 { 2258 uint64_t threshold = -bound % bound; 2259 for (;;) { 2260 uint64_t r = pcg_oneseq_64_xsl_rr_rr_64_random_r(rng); 2261 if (r >= threshold) 2262 return r % bound; 2263 } 2264 } 2265 2266 #if PCG_HAS_128BIT_OPS 2267 inline pcg128_t pcg_oneseq_128_xsl_rr_rr_128_random_r(struct pcg_state_128* rng) 2268 { 2269 pcg_oneseq_128_step_r(rng); 2270 return pcg_output_xsl_rr_rr_128_128(rng->state); 2271 } 2272 #endif 2273 2274 #if PCG_HAS_128BIT_OPS 2275 inline pcg128_t 2276 pcg_oneseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128* rng, 2277 pcg128_t bound) 2278 { 2279 pcg128_t threshold = -bound % bound; 2280 for (;;) { 2281 pcg128_t r = pcg_oneseq_128_xsl_rr_rr_128_random_r(rng); 2282 if (r >= threshold) 2283 return r % bound; 2284 } 2285 } 2286 #endif 2287 2288 inline uint64_t pcg_unique_64_xsl_rr_rr_64_random_r(struct pcg_state_64* rng) 2289 { 2290 uint64_t oldstate = rng->state; 2291 pcg_unique_64_step_r(rng); 2292 return pcg_output_xsl_rr_rr_64_64(oldstate); 2293 } 2294 2295 inline uint64_t 2296 pcg_unique_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_64* rng, 2297 uint64_t bound) 2298 { 2299 uint64_t threshold = -bound % bound; 2300 for (;;) { 2301 uint64_t r = pcg_unique_64_xsl_rr_rr_64_random_r(rng); 2302 if (r >= threshold) 2303 return r % bound; 2304 } 2305 } 2306 2307 #if PCG_HAS_128BIT_OPS 2308 inline pcg128_t pcg_unique_128_xsl_rr_rr_128_random_r(struct pcg_state_128* rng) 2309 { 2310 pcg_unique_128_step_r(rng); 2311 return pcg_output_xsl_rr_rr_128_128(rng->state); 2312 } 2313 #endif 2314 2315 #if PCG_HAS_128BIT_OPS 2316 inline pcg128_t 2317 pcg_unique_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128* rng, 2318 pcg128_t bound) 2319 { 2320 pcg128_t threshold = -bound % bound; 2321 for (;;) { 2322 pcg128_t r = pcg_unique_128_xsl_rr_rr_128_random_r(rng); 2323 if (r >= threshold) 2324 return r % bound; 2325 } 2326 } 2327 #endif 2328 2329 inline uint64_t 2330 pcg_setseq_64_xsl_rr_rr_64_random_r(struct pcg_state_setseq_64* rng) 2331 { 2332 uint64_t oldstate = rng->state; 2333 pcg_setseq_64_step_r(rng); 2334 return pcg_output_xsl_rr_rr_64_64(oldstate); 2335 } 2336 2337 inline uint64_t 2338 pcg_setseq_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_setseq_64* rng, 2339 uint64_t bound) 2340 { 2341 uint64_t threshold = -bound % bound; 2342 for (;;) { 2343 uint64_t r = pcg_setseq_64_xsl_rr_rr_64_random_r(rng); 2344 if (r >= threshold) 2345 return r % bound; 2346 } 2347 } 2348 2349 #if PCG_HAS_128BIT_OPS 2350 inline pcg128_t 2351 pcg_setseq_128_xsl_rr_rr_128_random_r(struct pcg_state_setseq_128* rng) 2352 { 2353 pcg_setseq_128_step_r(rng); 2354 return pcg_output_xsl_rr_rr_128_128(rng->state); 2355 } 2356 #endif 2357 2358 #if PCG_HAS_128BIT_OPS 2359 inline pcg128_t 2360 pcg_setseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_setseq_128* rng, 2361 pcg128_t bound) 2362 { 2363 pcg128_t threshold = -bound % bound; 2364 for (;;) { 2365 pcg128_t r = pcg_setseq_128_xsl_rr_rr_128_random_r(rng); 2366 if (r >= threshold) 2367 return r % bound; 2368 } 2369 } 2370 #endif 2371 2372 /*** Typedefs */ 2373 typedef struct pcg_state_setseq_64 pcg32_random_t; 2374 typedef struct pcg_state_64 pcg32s_random_t; 2375 typedef struct pcg_state_64 pcg32u_random_t; 2376 typedef struct pcg_state_64 pcg32f_random_t; 2377 /*** random_r */ 2378 #define pcg32_random_r pcg_setseq_64_xsh_rr_32_random_r 2379 #define pcg32s_random_r pcg_oneseq_64_xsh_rr_32_random_r 2380 #define pcg32u_random_r pcg_unique_64_xsh_rr_32_random_r 2381 #define pcg32f_random_r pcg_mcg_64_xsh_rs_32_random_r 2382 /*** boundedrand_r */ 2383 #define pcg32_boundedrand_r pcg_setseq_64_xsh_rr_32_boundedrand_r 2384 #define pcg32s_boundedrand_r pcg_oneseq_64_xsh_rr_32_boundedrand_r 2385 #define pcg32u_boundedrand_r pcg_unique_64_xsh_rr_32_boundedrand_r 2386 #define pcg32f_boundedrand_r pcg_mcg_64_xsh_rs_32_boundedrand_r 2387 /*** srandom_r */ 2388 #define pcg32_srandom_r pcg_setseq_64_srandom_r 2389 #define pcg32s_srandom_r pcg_oneseq_64_srandom_r 2390 #define pcg32u_srandom_r pcg_unique_64_srandom_r 2391 #define pcg32f_srandom_r pcg_mcg_64_srandom_r 2392 /*** advance_r */ 2393 #define pcg32_advance_r pcg_setseq_64_advance_r 2394 #define pcg32s_advance_r pcg_oneseq_64_advance_r 2395 #define pcg32u_advance_r pcg_unique_64_advance_r 2396 #define pcg32f_advance_r pcg_mcg_64_advance_r 2397 2398 #if PCG_HAS_128BIT_OPS 2399 /*** Typedefs */ 2400 typedef struct pcg_state_setseq_128 pcg64_random_t; 2401 typedef struct pcg_state_128 pcg64s_random_t; 2402 typedef struct pcg_state_128 pcg64u_random_t; 2403 typedef struct pcg_state_128 pcg64f_random_t; 2404 /*** random_r */ 2405 #define pcg64_random_r pcg_setseq_128_xsl_rr_64_random_r 2406 #define pcg64s_random_r pcg_oneseq_128_xsl_rr_64_random_r 2407 #define pcg64u_random_r pcg_unique_128_xsl_rr_64_random_r 2408 #define pcg64f_random_r pcg_mcg_128_xsl_rr_64_random_r 2409 /*** boundedrand_r */ 2410 #define pcg64_boundedrand_r pcg_setseq_128_xsl_rr_64_boundedrand_r 2411 #define pcg64s_boundedrand_r pcg_oneseq_128_xsl_rr_64_boundedrand_r 2412 #define pcg64u_boundedrand_r pcg_unique_128_xsl_rr_64_boundedrand_r 2413 #define pcg64f_boundedrand_r pcg_mcg_128_xsl_rr_64_boundedrand_r 2414 /*** srandom_r */ 2415 #define pcg64_srandom_r pcg_setseq_128_srandom_r 2416 #define pcg64s_srandom_r pcg_oneseq_128_srandom_r 2417 #define pcg64u_srandom_r pcg_unique_128_srandom_r 2418 #define pcg64f_srandom_r pcg_mcg_128_srandom_r 2419 /*** advance_r */ 2420 #define pcg64_advance_r pcg_setseq_128_advance_r 2421 #define pcg64s_advance_r pcg_oneseq_128_advance_r 2422 #define pcg64u_advance_r pcg_unique_128_advance_r 2423 #define pcg64f_advance_r pcg_mcg_128_advance_r 2424 #endif 2425 2426 /*** Typedefs */ 2427 typedef struct pcg_state_8 pcg8si_random_t; 2428 typedef struct pcg_state_16 pcg16si_random_t; 2429 typedef struct pcg_state_32 pcg32si_random_t; 2430 typedef struct pcg_state_64 pcg64si_random_t; 2431 /*** random_r */ 2432 #define pcg8si_random_r pcg_oneseq_8_rxs_m_xs_8_random_r 2433 #define pcg16si_random_r pcg_oneseq_16_rxs_m_xs_16_random_r 2434 #define pcg32si_random_r pcg_oneseq_32_rxs_m_xs_32_random_r 2435 #define pcg64si_random_r pcg_oneseq_64_rxs_m_xs_64_random_r 2436 /*** boundedrand_r */ 2437 #define pcg8si_boundedrand_r pcg_oneseq_8_rxs_m_xs_8_boundedrand_r 2438 #define pcg16si_boundedrand_r pcg_oneseq_16_rxs_m_xs_16_boundedrand_r 2439 #define pcg32si_boundedrand_r pcg_oneseq_32_rxs_m_xs_32_boundedrand_r 2440 #define pcg64si_boundedrand_r pcg_oneseq_64_rxs_m_xs_64_boundedrand_r 2441 /*** srandom_r */ 2442 #define pcg8si_srandom_r pcg_oneseq_8_srandom_r 2443 #define pcg16si_srandom_r pcg_oneseq_16_srandom_r 2444 #define pcg32si_srandom_r pcg_oneseq_32_srandom_r 2445 #define pcg64si_srandom_r pcg_oneseq_64_srandom_r 2446 /*** advance_r */ 2447 #define pcg8si_advance_r pcg_oneseq_8_advance_r 2448 #define pcg16si_advance_r pcg_oneseq_16_advance_r 2449 #define pcg32si_advance_r pcg_oneseq_32_advance_r 2450 #define pcg64si_advance_r pcg_oneseq_64_advance_r 2451 2452 #if PCG_HAS_128BIT_OPS 2453 typedef struct pcg_state_128 pcg128si_random_t; 2454 #define pcg128si_random_r pcg_oneseq_128_rxs_m_xs_128_random_r 2455 #define pcg128si_boundedrand_r pcg_oneseq_128_rxs_m_xs_128_boundedrand_r 2456 #define pcg128si_srandom_r pcg_oneseq_128_srandom_r 2457 #define pcg128si_advance_r pcg_oneseq_128_advance_r 2458 #endif 2459 2460 /*** Typedefs */ 2461 typedef struct pcg_state_setseq_8 pcg8i_random_t; 2462 typedef struct pcg_state_setseq_16 pcg16i_random_t; 2463 typedef struct pcg_state_setseq_32 pcg32i_random_t; 2464 typedef struct pcg_state_setseq_64 pcg64i_random_t; 2465 /*** random_r */ 2466 #define pcg8i_random_r pcg_setseq_8_rxs_m_xs_8_random_r 2467 #define pcg16i_random_r pcg_setseq_16_rxs_m_xs_16_random_r 2468 #define pcg32i_random_r pcg_setseq_32_rxs_m_xs_32_random_r 2469 #define pcg64i_random_r pcg_setseq_64_rxs_m_xs_64_random_r 2470 /*** boundedrand_r */ 2471 #define pcg8i_boundedrand_r pcg_setseq_8_rxs_m_xs_8_boundedrand_r 2472 #define pcg16i_boundedrand_r pcg_setseq_16_rxs_m_xs_16_boundedrand_r 2473 #define pcg32i_boundedrand_r pcg_setseq_32_rxs_m_xs_32_boundedrand_r 2474 #define pcg64i_boundedrand_r pcg_setseq_64_rxs_m_xs_64_boundedrand_r 2475 /*** srandom_r */ 2476 #define pcg8i_srandom_r pcg_setseq_8_srandom_r 2477 #define pcg16i_srandom_r pcg_setseq_16_srandom_r 2478 #define pcg32i_srandom_r pcg_setseq_32_srandom_r 2479 #define pcg64i_srandom_r pcg_setseq_64_srandom_r 2480 /*** advance_r */ 2481 #define pcg8i_advance_r pcg_setseq_8_advance_r 2482 #define pcg16i_advance_r pcg_setseq_16_advance_r 2483 #define pcg32i_advance_r pcg_setseq_32_advance_r 2484 #define pcg64i_advance_r pcg_setseq_64_advance_r 2485 2486 #if PCG_HAS_128BIT_OPS 2487 typedef struct pcg_state_setseq_128 pcg128i_random_t; 2488 #define pcg128i_random_r pcg_setseq_128_rxs_m_xs_128_random_r 2489 #define pcg128i_boundedrand_r pcg_setseq_128_rxs_m_xs_128_boundedrand_r 2490 #define pcg128i_srandom_r pcg_setseq_128_srandom_r 2491 #define pcg128i_advance_r pcg_setseq_128_advance_r 2492 #endif 2493 2494 extern uint32_t pcg32_random(void); 2495 extern uint32_t pcg32_boundedrand(uint32_t bound); 2496 extern void pcg32_srandom(uint64_t seed, uint64_t seq); 2497 extern void pcg32_advance(uint64_t delta); 2498 2499 #if PCG_HAS_128BIT_OPS 2500 extern uint64_t pcg64_random(void); 2501 extern uint64_t pcg64_boundedrand(uint64_t bound); 2502 extern void pcg64_srandom(pcg128_t seed, pcg128_t seq); 2503 extern void pcg64_advance(pcg128_t delta); 2504 #endif 2505 2506 /* 2507 * Static initialization constants (if you can't call srandom for some 2508 * bizarre reason). 2509 */ 2510 2511 #define PCG32_INITIALIZER PCG_STATE_SETSEQ_64_INITIALIZER 2512 #define PCG32U_INITIALIZER PCG_STATE_UNIQUE_64_INITIALIZER 2513 #define PCG32S_INITIALIZER PCG_STATE_ONESEQ_64_INITIALIZER 2514 #define PCG32F_INITIALIZER PCG_STATE_MCG_64_INITIALIZER 2515 2516 #if PCG_HAS_128BIT_OPS 2517 #define PCG64_INITIALIZER PCG_STATE_SETSEQ_128_INITIALIZER 2518 #define PCG64U_INITIALIZER PCG_STATE_UNIQUE_128_INITIALIZER 2519 #define PCG64S_INITIALIZER PCG_STATE_ONESEQ_128_INITIALIZER 2520 #define PCG64F_INITIALIZER PCG_STATE_MCG_128_INITIALIZER 2521 #endif 2522 2523 #define PCG8SI_INITIALIZER PCG_STATE_ONESEQ_8_INITIALIZER 2524 #define PCG16SI_INITIALIZER PCG_STATE_ONESEQ_16_INITIALIZER 2525 #define PCG32SI_INITIALIZER PCG_STATE_ONESEQ_32_INITIALIZER 2526 #define PCG64SI_INITIALIZER PCG_STATE_ONESEQ_64_INITIALIZER 2527 #if PCG_HAS_128BIT_OPS 2528 #define PCG128SI_INITIALIZER PCG_STATE_ONESEQ_128_INITIALIZER 2529 #endif 2530 2531 #define PCG8I_INITIALIZER PCG_STATE_SETSEQ_8_INITIALIZER 2532 #define PCG16I_INITIALIZER PCG_STATE_SETSEQ_16_INITIALIZER 2533 #define PCG32I_INITIALIZER PCG_STATE_SETSEQ_32_INITIALIZER 2534 #define PCG64I_INITIALIZER PCG_STATE_SETSEQ_64_INITIALIZER 2535 #if PCG_HAS_128BIT_OPS 2536 #define PCG128I_INITIALIZER PCG_STATE_SETSEQ_128_INITIALIZER 2537 #endif 2538 2539 #if __cplusplus 2540 } 2541 #endif 2542 2543 #endif /* PCG_VARIANTS_H_INCLUDED */ 2544 2545