Merge pull request #877 from newpavlov/patch-3
A minor rand_core docs update
diff --git a/.travis.yml b/.travis.yml
index f3790dc..bb4ce0f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,160 +1,42 @@
language: rust
sudo: false
-# We support too many combinations of Rust releases, crate features, operating
-# systems, and architectures to even remotely test all combinations.
-# Yet it turns out we can test most of these independent of each other, because
-# they serve different goals or test different pieces of code.
-#
-# RUST RELEASES
-# Goal: make sure we don't use language features unavailable on a certain
-# version, and build without warnings.
-# We have different builders use 4 Rust releases, a pinned stable release,
-# the latest stable, beta and nightly.
-#
-# ARCHITECTURES
-# Goal: test against issues caused by differences in endianness, pointer sizes,
-# etc.
-# We run tests on 4 different architectures.
-# - x64_84, default on Travis (Linux) and AppVeyor (Windows)
-# - i686, second AppVeyor (Windows) configuration
-# - MIPS, big-endian Linux emulated with QEMU (thanks to Trust)
-# - ARMv7, Android emulated with QEMU (thanks to Trust)
-#
-# OPERATING SYSTEMS
-# Goal: test on many operating systems, to verify the OsRng code, which is
-# mostly architecture-independent.
-# We run tests on Linux, OS X, Windows, Android (emulated), and Node.js (using
-# cargo-web).
-# One builder cross-compiles for many of the remaining OSes, which ensures we
-# keep building, but doesn't run tests.
-# OSes supported by Rand but which we can't cross-compile because there
-# is no pre-built standard library available: Dragonfly BSD, Haiku, OpenBSD.
-#
-# CRATE FEATURES, TESTS, AND SUB-CRATES
-# Goal: Run unit tests, doctests, examples, and test benchmarks for all crates,
-# in configurations that cover all interesting combinations of features.
-# Tests run on rand:
-# - test no_std support, but only the unit tests:
-# `cargo test --tests --no-default-features`
-# - test no_std support, including the alloc feature:
-# cargo test --tests --no-default-features --features=alloc
-# - run unit tests and doctests with all features which are available on stable:
-# `cargo test --features=serde1,log`
-# - test examples:
-# `cargo test --examples`
-# Additional tests on nightly:
-# - run unit tests and doctests with all features which are available on nightly:
-# `cargo test --all-features`
-# - run benchmarks as tests:
-# `cargo test --benches --features=nightly`
-# Tests on subcrates:
-# - select crates via --manifest-path (more reliable than --package)
-# - test appropriate feature matrix
-#
-# TODO: SIMD support on stable releases
-# NOTE: SIMD support is unreliable on nightly; we track the latest release
-# NOTE: Test for alloc feature in no_std is not included here because it depends
-# on the alloc crate stabilized in Rust 1.36.
+# Since most OS-specific code has moved to the getrandom crate, we require
+# few target-specific tests here.
+
matrix:
include:
- rust: 1.32.0
- env: DESCRIPTION="Linux, 1.32.0"
+ name: "Linux, 1.32.0"
+ env: ALLOC=0
os: linux
- script:
- # Differs from standard script: rand_pcg features
- - cargo test --tests --no-default-features
- # TODO: add simd_support feature:
- - cargo test --features=serde1,log
- - cargo test --examples
- - cargo test --manifest-path rand_core/Cargo.toml
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features
- - cargo test --manifest-path rand_distr/Cargo.toml
- - cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
- # TODO: cannot test rand_pcg due to explicit dependency on i128
- - cargo test --manifest-path rand_xorshift/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xoshiro/Cargo.toml
- - cargo test --manifest-path rand_chacha/Cargo.toml
- - cargo test --manifest-path rand_hc/Cargo.toml
- - cargo test --manifest-path rand_jitter/Cargo.toml
- - cargo test --manifest-path rand_os/Cargo.toml
-
- - rust: 1.32.0
- env: DESCRIPTION="OSX, 1.32.0"
- os: osx
- script:
- # Differs from standard script: rand_pcg features
- - cargo test --tests --no-default-features
- # TODO: add simd_support feature:
- - cargo test --features=serde1,log
- - cargo test --examples
- - cargo test --manifest-path rand_core/Cargo.toml
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features
- - cargo test --manifest-path rand_distr/Cargo.toml
- - cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
- # TODO: cannot test rand_pcg due to explicit dependency on i128
- - cargo test --manifest-path rand_xorshift/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xoshiro/Cargo.toml
- - cargo test --manifest-path rand_chacha/Cargo.toml
- - cargo test --manifest-path rand_hc/Cargo.toml
- - cargo test --manifest-path rand_jitter/Cargo.toml
- - cargo test --manifest-path rand_os/Cargo.toml
- rust: stable
- env: DESCRIPTION="Linux, stable"
+ name: "Linux, stable"
- rust: stable
- env: DESCRIPTION="OSX+iOS, stable"
+ name: "OSX+iOS, stable"
os: osx
install:
- rustup target add aarch64-apple-ios
script:
- # Differs from standard script: includes aarch64-apple-ios cross-build
- - cargo test --tests --no-default-features
- # TODO: add simd_support feature:
- - cargo test --features=serde1,log
- - cargo test --examples
- - cargo test --manifest-path rand_core/Cargo.toml
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features
- - cargo test --manifest-path rand_distr/Cargo.toml
- - cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_pcg/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xorshift/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xoshiro/Cargo.toml
- - cargo test --manifest-path rand_chacha/Cargo.toml
- - cargo test --manifest-path rand_hc/Cargo.toml
- - cargo test --manifest-path rand_jitter/Cargo.toml
- - cargo test --manifest-path rand_os/Cargo.toml
+ - bash utils/ci/script.sh
- cargo build --target=aarch64-apple-ios
- rust: beta
- env: DESCRIPTION="Linux, beta"
+ name: "Linux, beta"
- rust: nightly
os: linux
- env: DESCRIPTION="Linux, nightly, docs"
+ name: "Linux, nightly, docs"
+ env: NIGHTLY=1
install:
- cargo --list | egrep "^\s*deadlinks$" -q || cargo install cargo-deadlinks
- cargo deadlinks -V
before_script:
- pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
script:
- # Differs from standard script: all features, doc build
- - cargo test --tests --no-default-features --features=alloc
- - cargo test --all-features
- - cargo test --benches --features=nightly
- - cargo test --examples
- - cargo test --manifest-path rand_core/Cargo.toml
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features --features=alloc
- - cargo test --manifest-path rand_distr/Cargo.toml
- - cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_pcg/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xorshift/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xoshiro/Cargo.toml
- - cargo test --manifest-path rand_chacha/Cargo.toml
- - cargo test --manifest-path rand_hc/Cargo.toml
- - cargo test --manifest-path rand_jitter/Cargo.toml
- - cargo test --manifest-path rand_os/Cargo.toml
+ - bash utils/ci/script.sh
# remove cached documentation, otherwise files from previous PRs can get included
- rm -rf target/doc
- cargo doc --no-deps --all --all-features
@@ -162,103 +44,20 @@
after_success:
- travis-cargo --only nightly doc-upload
- - rust: nightly
- os: osx
- env: DESCRIPTION="OSX, nightly, docs"
- install:
- - cargo --list | egrep "^\s*deadlinks$" -q || cargo install cargo-deadlinks
- - cargo deadlinks -V
- script:
- # Differs from standard script: all features, doc build
- - cargo test --tests --no-default-features --features=alloc
- - cargo test --all-features
- - cargo test --benches --features=nightly
- - cargo test --examples
- - cargo test --manifest-path rand_core/Cargo.toml
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features --features=alloc
- - cargo test --manifest-path rand_distr/Cargo.toml
- - cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_pcg/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xorshift/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xoshiro/Cargo.toml
- - cargo test --manifest-path rand_chacha/Cargo.toml
- - cargo test --manifest-path rand_hc/Cargo.toml
- - cargo test --manifest-path rand_jitter/Cargo.toml
- - cargo test --manifest-path rand_os/Cargo.toml
- # remove cached documentation, otherwise files from previous PRs can get included
- - rm -rf target/doc
- - cargo doc --no-deps --all --all-features
- - cargo deadlinks --dir target/doc
-
- - rust: nightly
- env: DESCRIPTION="WASM via emscripten, stdweb and wasm-bindgen"
- install:
- - rustup target add wasm32-unknown-unknown
- - rustup target add wasm32-unknown-emscripten
- - nvm install 9
- - ./utils/ci/install_cargo_web.sh
- - cargo web prepare-emscripten
- - cargo web -V
- - cargo list | grep install-update || cargo install -f cargo-update
- - cargo install-update -i cargo-update wasm-bindgen-cli wasm-pack
- addons:
- chrome: stable
- script:
- # Testing wasm32-unknown-emscripten fails because of rust-lang/rust#49877
- # However, we can still build and link all tests to make sure that works.
- # This is actually useful as it finds stuff such as rust-random/rand#669
- - EMCC_CFLAGS="-s ERROR_ON_UNDEFINED_SYMBOLS=0" cargo web test --target wasm32-unknown-emscripten --no-run
- #- cargo web test --target wasm32-unknown-emscripten
- #- cargo web test --nodejs --target wasm32-unknown-emscripten
- #- cargo build --target wasm32-unknown-unknown # without any features
- - cargo build --target wasm32-unknown-unknown --features=wasm-bindgen
- - cargo web test --target wasm32-unknown-unknown --features=stdweb
- - cargo build --manifest-path tests/wasm_bindgen/Cargo.toml --target wasm32-unknown-unknown
- - wasm-bindgen --nodejs target/wasm32-unknown-unknown/debug/rand_wasm_bindgen_test.wasm --out-dir tests/wasm_bindgen/js
- - node tests/wasm_bindgen/js/index.js
- - wasm-pack test --node tests/wasm_bindgen
-
- - rust: nightly
- env: DESCRIPTION="cross-platform builder (doesn't run tests)"
- install:
- - rustup target add x86_64-sun-solaris
- - rustup target add x86_64-unknown-cloudabi
- - rustup target add x86_64-unknown-freebsd
- #- rustup target add x86_64-unknown-fuchsia
- - rustup target add x86_64-unknown-netbsd
- - rustup target add x86_64-unknown-redox
- script:
- # Test the top-level crate with all features:
- - cargo build --target=x86_64-sun-solaris --all-features
- - cargo build --target=x86_64-unknown-cloudabi --all-features
- - cargo build --target=x86_64-unknown-freebsd --all-features
- #- cargo build --target=x86_64-unknown-fuchsia --all-features
- - cargo build --target=x86_64-unknown-netbsd --all-features
- - cargo build --target=x86_64-unknown-redox --all-features
-
- # Trust cross-built/emulated targets. We must repeat all non-default values.
+ # This target catches endianness issues
- rust: stable
sudo: required
dist: trusty
services: docker
- env: DESCRIPTION="Linux (MIPS, big-endian)" TARGET=mips-unknown-linux-gnu
+ name: "Linux (MIPS, big-endian)"
+ env: TARGET=mips-unknown-linux-gnu
install:
- sh utils/ci/install.sh
- source ~/.cargo/env || true
- script:
- - bash utils/ci/script.sh
- - rust: stable
- sudo: required
- dist: trusty
- services: docker
- env: DESCRIPTION="Android (ARMv7)" TARGET=armv7-linux-androideabi
- install:
- - sh utils/ci/install.sh
- - source ~/.cargo/env || true
- script:
- - bash utils/ci/script.sh
+
+ # This target checks we really can build no_std binaries
- rust: nightly
- env: DESCRIPTION="no_std platform test"
+ name: "no_std platform test"
install:
- rustup target add thumbv6m-none-eabi
script:
@@ -267,44 +66,35 @@
- rust: nightly
os: linux
- env: DESCRIPTION="Miri, nightly"
+ name: "Miri, nightly"
script:
- sh utils/ci/miri.sh
+
+ - rust: nightly
+ os: linux
+ name: "Minimal dep versions"
+ script:
+ - cargo generate-lockfile -Z minimal-versions
+ - bash utils/ci/script.sh
before_install:
- set -e
- rustup self update
script:
- - cargo test --tests --no-default-features
- - cargo test --tests --no-default-features --features getrandom
- - cargo test --tests --no-default-features --features=alloc
- # TODO: add simd_support feature:
- - cargo test --features=serde1,log
- - cargo test --examples
- - cargo test --manifest-path rand_core/Cargo.toml
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features
- - cargo test --manifest-path rand_core/Cargo.toml --no-default-features --features=alloc
- - cargo test --manifest-path rand_distr/Cargo.toml
- - cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_pcg/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xorshift/Cargo.toml --features=serde1
- - cargo test --manifest-path rand_xoshiro/Cargo.toml
- - cargo test --manifest-path rand_chacha/Cargo.toml
- - cargo test --manifest-path rand_hc/Cargo.toml
- - cargo test --manifest-path rand_jitter/Cargo.toml
- - cargo test --manifest-path rand_os/Cargo.toml
+ - bash utils/ci/script.sh
after_script: set +e
-cache:
- cargo: true
- directories:
- - .local/share/cargo-web
+# Cache: this seems to do more harm than good
+#cache:
+ #cargo: true
+ #directories:
+ #- .local/share/cargo-web
-before_cache:
- # Travis can't cache files that are not readable by "others"
- - chmod -R a+r $HOME/.cargo
+#before_cache:
+ ## Travis can't cache files that are not readable by "others"
+ #- chmod -R a+r $HOME/.cargo
env:
global:
diff --git a/Cargo.toml b/Cargo.toml
index b87559a..fead913 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,7 +60,7 @@
# This is a dependency because: we forward wasm feature flags
# This is renamed because: we need getrandom to depend on rand_core/getrandom
getrandom_package = { version = "0.1.1", package = "getrandom", optional = true }
-log = { version = "0.4", optional = true }
+log = { version = "0.4.4", optional = true }
[dependencies.packed_simd]
# NOTE: so far no version works reliably due to dependence on unstable features
@@ -84,7 +84,7 @@
rand_pcg = { path = "rand_pcg", version = "0.2" }
# Only for benches:
rand_hc = { path = "rand_hc", version = "0.2" }
-rand_xoshiro = { path = "rand_xoshiro", version = "0.3" }
+rand_xoshiro = { path = "rand_xoshiro", version = "0.4" }
rand_isaac = { path = "rand_isaac", version = "0.2" }
rand_xorshift = { path = "rand_xorshift", version = "0.2" }
diff --git a/appveyor.yml b/appveyor.yml
index ef0b4bf..a4cfbee 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -32,12 +32,14 @@
build: false
test_script:
- - cargo test --tests --no-default-features --features alloc
- # TODO: use --all-features once simd_support is sufficiently stable:
+ - cargo test --tests --no-default-features
+ - cargo test --tests --no-default-features --features=alloc,getrandom
+ # all stable features:
- cargo test --features=serde1,log
- cargo test --benches --features=nightly
- cargo test --examples
- cargo test --manifest-path rand_core/Cargo.toml
+ - cargo test --manifest-path rand_core/Cargo.toml --no-default-features
- cargo test --manifest-path rand_core/Cargo.toml --no-default-features --features=alloc
- cargo test --manifest-path rand_distr/Cargo.toml
- cargo test --manifest-path rand_isaac/Cargo.toml --features=serde1
@@ -46,4 +48,5 @@
- cargo test --manifest-path rand_xoshiro/Cargo.toml
- cargo test --manifest-path rand_chacha/Cargo.toml
- cargo test --manifest-path rand_hc/Cargo.toml
+ - cargo test --manifest-path rand_jitter/Cargo.toml
- cargo test --manifest-path rand_os/Cargo.toml
diff --git a/rand_distr/Cargo.toml b/rand_distr/Cargo.toml
index 315a5b0..8fbf33b 100644
--- a/rand_distr/Cargo.toml
+++ b/rand_distr/Cargo.toml
@@ -24,4 +24,4 @@
[dev-dependencies]
rand_pcg = { version = "0.2", path = "../rand_pcg" }
# Histogram implementation for testing uniformity
-average = "0.9.2"
+average = "0.10.3"
diff --git a/rand_isaac/Cargo.toml b/rand_isaac/Cargo.toml
index c11c305..a63ab18 100644
--- a/rand_isaac/Cargo.toml
+++ b/rand_isaac/Cargo.toml
@@ -23,9 +23,11 @@
[dependencies]
rand_core = { path = "../rand_core", version = "0.5" }
-serde = { version = "1", features = ["derive"], optional = true }
+serde = { version = "1.0.63", features = ["derive"], optional = true }
+# Not a direct dependency but required to boost the minimum version:
+serde_derive = { version = "1.0.63", optional = true }
[dev-dependencies]
# This is for testing serde, unfortunately we can't specify feature-gated dev
# deps yet, see: https://github.com/rust-lang/cargo/issues/1596
-bincode = "1"
+bincode = "1.1.4"
diff --git a/rand_xoshiro/CHANGELOG.md b/rand_xoshiro/CHANGELOG.md
index 56cb9c2..147303d 100644
--- a/rand_xoshiro/CHANGELOG.md
+++ b/rand_xoshiro/CHANGELOG.md
@@ -4,6 +4,12 @@
The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [0.4.0] - 2019-09-03
+- Add xoshiro128++, 256++ and 512++ variants
+- Add xoroshiro128++ variant
+- Add `long_jump` method to RNGs missing it
+- Update xoshiro128** to version 1.1, breaking value stability
+
## [0.3.1] - 2019-08-06
- Drop `byteorder`-dependency in favor of `stdlib`-implementation.
diff --git a/rand_xoshiro/Cargo.toml b/rand_xoshiro/Cargo.toml
index 128c213..b2ff499 100644
--- a/rand_xoshiro/Cargo.toml
+++ b/rand_xoshiro/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "rand_xoshiro"
-version = "0.3.1" # NB: When modifying, also modify html_root_url in lib.rs
+version = "0.4.0" # NB: When modifying, also modify html_root_url in lib.rs
authors = ["The Rand Project Developers"]
license = "MIT OR Apache-2.0"
readme = "README.md"
diff --git a/rand_xoshiro/src/common.rs b/rand_xoshiro/src/common.rs
index b188dd6..1af3543 100644
--- a/rand_xoshiro/src/common.rs
+++ b/rand_xoshiro/src/common.rs
@@ -28,6 +28,20 @@
}
}
+/// Apply the ++ scrambler used by some RNGs from the xoshiro family.
+macro_rules! plusplus_u64 {
+ ($x:expr, $y:expr, $rot:expr) => {
+ $x.wrapping_add($y).rotate_left($rot).wrapping_add($x)
+ }
+}
+
+/// Apply the ++ scrambler used by some RNGs from the xoshiro family.
+macro_rules! plusplus_u32 {
+ ($x:expr, $y:expr) => {
+ $x.wrapping_add($y).rotate_left(7).wrapping_add($x)
+ }
+}
+
/// Implement a jump function for an RNG from the xoshiro family.
macro_rules! impl_jump {
(u32, $self:expr, [$j0:expr, $j1:expr]) => {
@@ -147,6 +161,15 @@
}
}
+/// Implement the xoroshiro iteration for the ++ scrambler.
+macro_rules! impl_xoroshiro_u64_plusplus {
+ ($self:expr) => {
+ $self.s1 ^= $self.s0;
+ $self.s0 = $self.s0.rotate_left(49) ^ $self.s1 ^ ($self.s1 << 21);
+ $self.s1 = $self.s1.rotate_left(28);
+ }
+}
+
/// Implement the xoshiro iteration for `u32` output.
macro_rules! impl_xoshiro_u32 {
($self:expr) => {
diff --git a/rand_xoshiro/src/lib.rs b/rand_xoshiro/src/lib.rs
index 3047e92..d05e1cc 100644
--- a/rand_xoshiro/src/lib.rs
+++ b/rand_xoshiro/src/lib.rs
@@ -17,6 +17,8 @@
//! # 64-bit generators
//! - [`Xoshiro256StarStar`]: Recommended for all purposes. Excellent speed and
//! a state space (256 bits) large enough for any parallel application.
+//! - [`Xoshiro256PlusPlus`]: Recommended for all purposes. Excellent speed and
+//! a state space (256 bits) large enough for any parallel application.
//! - [`Xoshiro256Plus`]: Recommended for generating 64-bit floating-point
//! numbers. About 15% faster than `Xoshiro256StarStar`, but has a [low linear
//! complexity] in the lowest bits (which are discarded when generating
@@ -25,6 +27,9 @@
//! - [`Xoroshiro128StarStar`]: An alternative to `Xoshiro256StarStar`, having
//! the same speed but using half the state. Only suited for low-scale parallel
//! applications.
+//! - [`Xoroshiro128PlusPlus`]: An alternative to `Xoshiro256PlusPlus`, having
+//! the same speed but using half the state. Only suited for low-scale parallel
+//! applications.
//! - [`Xoroshiro128Plus`]: An alternative to `Xoshiro256Plus`, having the same
//! speed but using half the state. Only suited for low-scale parallel
//! applications. Has a [low linear complexity] in the lowest bits (which are
@@ -32,6 +37,8 @@
//! unlikely to have any impact in practise.
//! - [`Xoshiro512StarStar`]: An alternative to `Xoshiro256StarStar` with more
//! state and the same speed.
+//! - [`Xoshiro512PlusPlus`]: An alternative to `Xoshiro256PlusPlus` with more
+//! state and the same speed.
//! - [`Xoshiro512Plus`]: An alternative to `Xoshiro512Plus` with more
//! state and the same speed. Has a [low linear complexity] in the lowest bits
//! (which are discarded when generating floats), making it fail linearity
@@ -41,6 +48,7 @@
//!
//! # 32-bit generators
//! - [`Xoshiro128StarStar`]: Recommended for all purposes. Excellent speed.
+//! - [`Xoshiro128PlusPlus`]: Recommended for all purposes. Excellent speed.
//! - [`Xoshiro128Plus`]: Recommended for generating 32-bit floating-point
//! numbers. Faster than `Xoshiro128StarStar`, but has a [low linear
//! complexity] in the lowest bits (which are discarded when generating
@@ -53,12 +61,16 @@
//! lowest bits (which are discarded when generating floats), making it fail
//! linearity tests. This is unlikely to have any impact in practise.
//!
+//! The `*PlusPlus` generators perform similarily to the `*StarStar` generators.
+//! See the [xoshiro paper], where the differences are discussed in detail.
+//!
//! [xoshiro]: http://xoshiro.di.unimi.it/
+//! [xoshiro paper]: http://vigna.di.unimi.it/ftp/papers/ScrambledLinear.pdf
//! [low linear complexity]: http://xoshiro.di.unimi.it/lowcomp.php
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
html_favicon_url = "https://www.rust-lang.org/favicon.ico",
- html_root_url = "https://docs.rs/rand_xoshiro/0.3.1")]
+ html_root_url = "https://docs.rs/rand_xoshiro/0.4.0")]
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
@@ -69,12 +81,16 @@
mod common;
mod splitmix64;
mod xoshiro128starstar;
+mod xoshiro128plusplus;
mod xoshiro128plus;
mod xoshiro256starstar;
+mod xoshiro256plusplus;
mod xoshiro256plus;
mod xoshiro512starstar;
+mod xoshiro512plusplus;
mod xoshiro512plus;
mod xoroshiro128plus;
+mod xoroshiro128plusplus;
mod xoroshiro128starstar;
mod xoroshiro64starstar;
mod xoroshiro64star;
@@ -82,13 +98,17 @@
pub use rand_core;
pub use splitmix64::SplitMix64;
pub use xoshiro128starstar::Xoshiro128StarStar;
+pub use xoshiro128plusplus::Xoshiro128PlusPlus;
pub use xoshiro128plus::Xoshiro128Plus;
pub use xoshiro256starstar::Xoshiro256StarStar;
+pub use xoshiro256plusplus::Xoshiro256PlusPlus;
pub use xoshiro256plus::Xoshiro256Plus;
pub use common::Seed512;
pub use xoshiro512starstar::Xoshiro512StarStar;
+pub use xoshiro512plusplus::Xoshiro512PlusPlus;
pub use xoshiro512plus::Xoshiro512Plus;
pub use xoroshiro128plus::Xoroshiro128Plus;
pub use xoroshiro128starstar::Xoroshiro128StarStar;
+pub use xoroshiro128plusplus::Xoroshiro128PlusPlus;
pub use xoroshiro64starstar::Xoroshiro64StarStar;
pub use xoroshiro64star::Xoroshiro64Star;
diff --git a/rand_xoshiro/src/xoroshiro128plusplus.rs b/rand_xoshiro/src/xoroshiro128plusplus.rs
new file mode 100644
index 0000000..fa6bc68
--- /dev/null
+++ b/rand_xoshiro/src/xoroshiro128plusplus.rs
@@ -0,0 +1,127 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+use rand_core;
+use rand_core::le::read_u64_into;
+use rand_core::impls::fill_bytes_via_next;
+use rand_core::{RngCore, SeedableRng};
+
+/// A xoroshiro128++ random number generator.
+///
+/// The xoroshiro128++ algorithm is not suitable for cryptographic purposes, but
+/// is very fast and has excellent statistical properties.
+///
+/// The algorithm used here is translated from [the `xoroshiro128plusplus.c`
+/// reference source code](http://xoshiro.di.unimi.it/xoroshiro128plusplus.c) by
+/// David Blackman and Sebastiano Vigna.
+#[allow(missing_copy_implementations)]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
+pub struct Xoroshiro128PlusPlus {
+ s0: u64,
+ s1: u64,
+}
+
+impl Xoroshiro128PlusPlus {
+ /// Jump forward, equivalently to 2^64 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^64 non-overlapping subsequences for
+ /// parallel computations.
+ ///
+ /// ```
+ /// use rand_xoshiro::rand_core::SeedableRng;
+ /// use rand_xoshiro::Xoroshiro128PlusPlus;
+ ///
+ /// let rng1 = Xoroshiro128PlusPlus::seed_from_u64(0);
+ /// let mut rng2 = rng1.clone();
+ /// rng2.jump();
+ /// let mut rng3 = rng2.clone();
+ /// rng3.jump();
+ /// ```
+ pub fn jump(&mut self) {
+ impl_jump!(u64, self, [0x2bd7a6a6e99c2ddc, 0x0992ccaf6a6fca05]);
+ }
+
+ /// Jump forward, equivalently to 2^96 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^32 starting points, from each of which
+ /// `jump()` will generate 2^32 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u64, self, [0x360fd5f2cf8d5d99, 0x9c6e6877736c46e3]);
+ }
+}
+
+impl RngCore for Xoroshiro128PlusPlus {
+ #[inline]
+ fn next_u32(&mut self) -> u32 {
+ self.next_u64() as u32
+ }
+
+ #[inline]
+ fn next_u64(&mut self) -> u64 {
+ let r = plusplus_u64!(self.s0, self.s1, 17);
+ impl_xoroshiro_u64_plusplus!(self);
+ r
+ }
+
+ #[inline]
+ fn fill_bytes(&mut self, dest: &mut [u8]) {
+ fill_bytes_via_next(self, dest);
+ }
+
+ #[inline]
+ fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> {
+ self.fill_bytes(dest);
+ Ok(())
+ }
+}
+
+impl SeedableRng for Xoroshiro128PlusPlus {
+ type Seed = [u8; 16];
+
+ /// Create a new `Xoroshiro128PlusPlus`. If `seed` is entirely 0, it will be
+ /// mapped to a different seed.
+ fn from_seed(seed: [u8; 16]) -> Xoroshiro128PlusPlus {
+ deal_with_zero_seed!(seed, Self);
+ let mut s = [0; 2];
+ read_u64_into(&seed, &mut s);
+
+ Xoroshiro128PlusPlus {
+ s0: s[0],
+ s1: s[1],
+ }
+ }
+
+ /// Seed a `Xoroshiro128PlusPlus` from a `u64` using `SplitMix64`.
+ fn seed_from_u64(seed: u64) -> Xoroshiro128PlusPlus {
+ from_splitmix!(seed)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn reference() {
+ let mut rng = Xoroshiro128PlusPlus::from_seed(
+ [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0]);
+ // These values were produced with the reference implementation:
+ // http://xoshiro.di.unimi.it/xoshiro128plusplus.c
+ let expected = [
+ 393217, 669327710093319, 1732421326133921491, 11394790081659126983,
+ 9555452776773192676, 3586421180005889563, 1691397964866707553,
+ 10735626796753111697, 15216282715349408991, 14247243556711267923,
+ ];
+ for &e in &expected {
+ assert_eq!(rng.next_u64(), e);
+ }
+ }
+}
diff --git a/rand_xoshiro/src/xoshiro128plusplus.rs b/rand_xoshiro/src/xoshiro128plusplus.rs
new file mode 100644
index 0000000..3596c77
--- /dev/null
+++ b/rand_xoshiro/src/xoshiro128plusplus.rs
@@ -0,0 +1,120 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+use rand_core::impls::{next_u64_via_u32, fill_bytes_via_next};
+use rand_core::le::read_u32_into;
+use rand_core::{SeedableRng, RngCore, Error};
+
+/// A xoshiro128++ random number generator.
+///
+/// The xoshiro128++ algorithm is not suitable for cryptographic purposes, but
+/// is very fast and has excellent statistical properties.
+///
+/// The algorithm used here is translated from [the `xoshiro128plusplus.c`
+/// reference source code](http://xoshiro.di.unimi.it/xoshiro128plusplus.c) by
+/// David Blackman and Sebastiano Vigna.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
+pub struct Xoshiro128PlusPlus {
+ s: [u32; 4],
+}
+
+impl Xoshiro128PlusPlus {
+ /// Jump forward, equivalently to 2^64 calls to `next_u32()`.
+ ///
+ /// This can be used to generate 2^64 non-overlapping subsequences for
+ /// parallel computations.
+ ///
+ /// ```
+ /// use rand_xoshiro::rand_core::SeedableRng;
+ /// use rand_xoshiro::Xoroshiro128PlusPlus;
+ ///
+ /// let rng1 = Xoroshiro128PlusPlus::seed_from_u64(0);
+ /// let mut rng2 = rng1.clone();
+ /// rng2.jump();
+ /// let mut rng3 = rng2.clone();
+ /// rng3.jump();
+ /// ```
+ pub fn jump(&mut self) {
+ impl_jump!(u32, self, [0x8764000b, 0xf542d2d3, 0x6fa035c3, 0x77f2db5b]);
+ }
+
+ /// Jump forward, equivalently to 2^96 calls to `next_u32()`.
+ ///
+ /// This can be used to generate 2^32 starting points, from each of which
+ /// `jump()` will generate 2^32 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u32, self, [0xb523952e, 0x0b6f099f, 0xccf5a0ef, 0x1c580662]);
+ }
+}
+
+impl SeedableRng for Xoshiro128PlusPlus {
+ type Seed = [u8; 16];
+
+ /// Create a new `Xoshiro128PlusPlus`. If `seed` is entirely 0, it will be
+ /// mapped to a different seed.
+ #[inline]
+ fn from_seed(seed: [u8; 16]) -> Xoshiro128PlusPlus {
+ deal_with_zero_seed!(seed, Self);
+ let mut state = [0; 4];
+ read_u32_into(&seed, &mut state);
+ Xoshiro128PlusPlus { s: state }
+ }
+
+ /// Seed a `Xoshiro128PlusPlus` from a `u64` using `SplitMix64`.
+ fn seed_from_u64(seed: u64) -> Xoshiro128PlusPlus {
+ from_splitmix!(seed)
+ }
+}
+
+impl RngCore for Xoshiro128PlusPlus {
+ #[inline]
+ fn next_u32(&mut self) -> u32 {
+ let result_starstar = plusplus_u32!(self.s[0], self.s[3]);
+ impl_xoshiro_u32!(self);
+ result_starstar
+ }
+
+ #[inline]
+ fn next_u64(&mut self) -> u64 {
+ next_u64_via_u32(self)
+ }
+
+ #[inline]
+ fn fill_bytes(&mut self, dest: &mut [u8]) {
+ fill_bytes_via_next(self, dest);
+ }
+
+ #[inline]
+ fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+ self.fill_bytes(dest);
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn reference() {
+ let mut rng = Xoshiro128PlusPlus::from_seed(
+ [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0]);
+ // These values were produced with the reference implementation:
+ // http://xoshiro.di.unimi.it/xoshiro128plusplus.c
+ let expected = [
+ 641, 1573767, 3222811527, 3517856514, 836907274, 4247214768,
+ 3867114732, 1355841295, 495546011, 621204420,
+ ];
+ for &e in &expected {
+ assert_eq!(rng.next_u32(), e);
+ }
+ }
+}
diff --git a/rand_xoshiro/src/xoshiro128starstar.rs b/rand_xoshiro/src/xoshiro128starstar.rs
index 7af1e50..a355bbc 100644
--- a/rand_xoshiro/src/xoshiro128starstar.rs
+++ b/rand_xoshiro/src/xoshiro128starstar.rs
@@ -44,6 +44,15 @@
pub fn jump(&mut self) {
impl_jump!(u32, self, [0x8764000b, 0xf542d2d3, 0x6fa035c3, 0x77f2db5b]);
}
+
+ /// Jump forward, equivalently to 2^96 calls to `next_u32()`.
+ ///
+ /// This can be used to generate 2^32 starting points, from each of which
+ /// `jump()` will generate 2^32 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u32, self, [0xb523952e, 0x0b6f099f, 0xccf5a0ef, 0x1c580662]);
+ }
}
impl SeedableRng for Xoshiro128StarStar {
@@ -68,7 +77,7 @@
impl RngCore for Xoshiro128StarStar {
#[inline]
fn next_u32(&mut self) -> u32 {
- let result_starstar = starstar_u64!(self.s[0]);
+ let result_starstar = starstar_u64!(self.s[1]);
impl_xoshiro_u32!(self);
result_starstar
}
@@ -98,11 +107,11 @@
fn reference() {
let mut rng = Xoshiro128StarStar::from_seed(
[1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0]);
- // These values were produced with the reference implementation:
+ // These values were produced with the reference implementation (v1.1):
// http://xoshiro.di.unimi.it/xoshiro128starstar.c
let expected = [
- 5760, 40320, 70819200, 3297914139, 2480851620, 1792823698,
- 4118739149, 1251203317, 1581886583, 1721184582,
+ 11520, 0, 5927040, 70819200, 2031721883, 1637235492, 1287239034,
+ 3734860849, 3729100597, 4258142804,
];
for &e in &expected {
assert_eq!(rng.next_u32(), e);
diff --git a/rand_xoshiro/src/xoshiro256plusplus.rs b/rand_xoshiro/src/xoshiro256plusplus.rs
new file mode 100644
index 0000000..649e081
--- /dev/null
+++ b/rand_xoshiro/src/xoshiro256plusplus.rs
@@ -0,0 +1,128 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+use rand_core::impls::fill_bytes_via_next;
+use rand_core::le::read_u64_into;
+use rand_core::{SeedableRng, RngCore, Error};
+
+/// A xoshiro256** random number generator.
+///
+/// The xoshiro256** algorithm is not suitable for cryptographic purposes, but
+/// is very fast and has excellent statistical properties.
+///
+/// The algorithm used here is translated from [the `xoshiro256plusplus.c`
+/// reference source code](http://xoshiro.di.unimi.it/xoshiro256plusplus.c) by
+/// David Blackman and Sebastiano Vigna.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
+pub struct Xoshiro256PlusPlus {
+ s: [u64; 4],
+}
+
+impl Xoshiro256PlusPlus {
+ /// Jump forward, equivalently to 2^128 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^128 non-overlapping subsequences for
+ /// parallel computations.
+ ///
+ /// ```
+ /// use rand_xoshiro::rand_core::SeedableRng;
+ /// use rand_xoshiro::Xoshiro256PlusPlus;
+ ///
+ /// let rng1 = Xoshiro256PlusPlus::seed_from_u64(0);
+ /// let mut rng2 = rng1.clone();
+ /// rng2.jump();
+ /// let mut rng3 = rng2.clone();
+ /// rng3.jump();
+ /// ```
+ pub fn jump(&mut self) {
+ impl_jump!(u64, self, [
+ 0x180ec6d33cfd0aba, 0xd5a61266f0c9392c,
+ 0xa9582618e03fc9aa, 0x39abdc4529b1661c
+ ]);
+ }
+
+ /// Jump forward, equivalently to 2^192 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^64 starting points, from each of which
+ /// `jump()` will generate 2^64 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u64, self, [
+ 0x76e15d3efefdcbbf, 0xc5004e441c522fb3,
+ 0x77710069854ee241, 0x39109bb02acbe635
+ ]);
+ }
+}
+
+impl SeedableRng for Xoshiro256PlusPlus {
+ type Seed = [u8; 32];
+
+ /// Create a new `Xoshiro256PlusPlus`. If `seed` is entirely 0, it will be
+ /// mapped to a different seed.
+ #[inline]
+ fn from_seed(seed: [u8; 32]) -> Xoshiro256PlusPlus {
+ deal_with_zero_seed!(seed, Self);
+ let mut state = [0; 4];
+ read_u64_into(&seed, &mut state);
+ Xoshiro256PlusPlus { s: state }
+ }
+
+ /// Seed a `Xoshiro256PlusPlus` from a `u64` using `SplitMix64`.
+ fn seed_from_u64(seed: u64) -> Xoshiro256PlusPlus {
+ from_splitmix!(seed)
+ }
+}
+
+impl RngCore for Xoshiro256PlusPlus {
+ #[inline]
+ fn next_u32(&mut self) -> u32 {
+ self.next_u64() as u32
+ }
+
+ #[inline]
+ fn next_u64(&mut self) -> u64 {
+ let result_plusplus = plusplus_u64!(self.s[0], self.s[3], 23);
+ impl_xoshiro_u64!(self);
+ result_plusplus
+ }
+
+ #[inline]
+ fn fill_bytes(&mut self, dest: &mut [u8]) {
+ fill_bytes_via_next(self, dest);
+ }
+
+ #[inline]
+ fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+ self.fill_bytes(dest);
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn reference() {
+ let mut rng = Xoshiro256PlusPlus::from_seed(
+ [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
+ 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0]);
+ // These values were produced with the reference implementation:
+ // http://xoshiro.di.unimi.it/xoshiro256plusplus.c
+ let expected = [
+ 41943041, 58720359, 3588806011781223, 3591011842654386,
+ 9228616714210784205, 9973669472204895162, 14011001112246962877,
+ 12406186145184390807, 15849039046786891736, 10450023813501588000,
+ ];
+ for &e in &expected {
+ assert_eq!(rng.next_u64(), e);
+ }
+ }
+}
diff --git a/rand_xoshiro/src/xoshiro512plus.rs b/rand_xoshiro/src/xoshiro512plus.rs
index 4b589f2..baa3480 100644
--- a/rand_xoshiro/src/xoshiro512plus.rs
+++ b/rand_xoshiro/src/xoshiro512plus.rs
@@ -51,6 +51,19 @@
0x53851efdb6df0aaf, 0x1ebbc8b23eaf25db
]);
}
+
+ /// Jump forward, equivalently to 2^384 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^128 starting points, from each of which
+ /// `jump()` will generate 2^128 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u64, self, [
+ 0x11467fef8f921d28, 0xa2a819f2e79c8ea8, 0xa8299fc284b3959a,
+ 0xb4d347340ca63ee1, 0x1cb0940bedbff6ce, 0xd956c5c4fa1f8e17,
+ 0x915e38fd4eda93bc, 0x5b3ccdfa5d7daca5
+ ]);
+ }
}
impl SeedableRng for Xoshiro512Plus {
diff --git a/rand_xoshiro/src/xoshiro512plusplus.rs b/rand_xoshiro/src/xoshiro512plusplus.rs
new file mode 100644
index 0000000..6f967f5
--- /dev/null
+++ b/rand_xoshiro/src/xoshiro512plusplus.rs
@@ -0,0 +1,135 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[cfg(feature="serde1")] use serde::{Serialize, Deserialize};
+use rand_core::impls::fill_bytes_via_next;
+use rand_core::le::read_u64_into;
+use rand_core::{SeedableRng, RngCore, Error};
+
+use crate::Seed512;
+
+/// A xoshiro512++ random number generator.
+///
+/// The xoshiro512++ algorithm is not suitable for cryptographic purposes, but
+/// is very fast and has excellent statistical properties.
+///
+/// The algorithm used here is translated from [the `xoshiro512plusplus.c`
+/// reference source code](http://xoshiro.di.unimi.it/xoshiro512plusplus.c) by
+/// David Blackman and Sebastiano Vigna.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature="serde1", derive(Serialize, Deserialize))]
+pub struct Xoshiro512PlusPlus {
+ s: [u64; 8],
+}
+
+impl Xoshiro512PlusPlus {
+ /// Jump forward, equivalently to 2^256 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^256 non-overlapping subsequences for
+ /// parallel computations.
+ ///
+ /// ```
+ /// use rand_xoshiro::rand_core::SeedableRng;
+ /// use rand_xoshiro::Xoshiro512PlusPlus;
+ ///
+ /// let rng1 = Xoshiro512PlusPlus::seed_from_u64(0);
+ /// let mut rng2 = rng1.clone();
+ /// rng2.jump();
+ /// let mut rng3 = rng2.clone();
+ /// rng3.jump();
+ /// ```
+ pub fn jump(&mut self) {
+ impl_jump!(u64, self, [
+ 0x33ed89b6e7a353f9, 0x760083d7955323be, 0x2837f2fbb5f22fae,
+ 0x4b8c5674d309511c, 0xb11ac47a7ba28c25, 0xf1be7667092bcc1c,
+ 0x53851efdb6df0aaf, 0x1ebbc8b23eaf25db
+ ]);
+ }
+
+ /// Jump forward, equivalently to 2^384 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^128 starting points, from each of which
+ /// `jump()` will generate 2^128 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u64, self, [
+ 0x11467fef8f921d28, 0xa2a819f2e79c8ea8, 0xa8299fc284b3959a,
+ 0xb4d347340ca63ee1, 0x1cb0940bedbff6ce, 0xd956c5c4fa1f8e17,
+ 0x915e38fd4eda93bc, 0x5b3ccdfa5d7daca5
+ ]);
+ }
+}
+
+
+impl SeedableRng for Xoshiro512PlusPlus {
+ type Seed = Seed512;
+
+ /// Create a new `Xoshiro512PlusPlus`. If `seed` is entirely 0, it will be
+ /// mapped to a different seed.
+ #[inline]
+ fn from_seed(seed: Seed512) -> Xoshiro512PlusPlus {
+ deal_with_zero_seed!(seed, Self);
+ let mut state = [0; 8];
+ read_u64_into(&seed.0, &mut state);
+ Xoshiro512PlusPlus { s: state }
+ }
+
+ /// Seed a `Xoshiro512PlusPlus` from a `u64` using `SplitMix64`.
+ fn seed_from_u64(seed: u64) -> Xoshiro512PlusPlus {
+ from_splitmix!(seed)
+ }
+}
+
+impl RngCore for Xoshiro512PlusPlus {
+ #[inline]
+ fn next_u32(&mut self) -> u32 {
+ self.next_u64() as u32
+ }
+
+ #[inline]
+ fn next_u64(&mut self) -> u64 {
+ let result_plusplus = plusplus_u64!(self.s[2], self.s[0], 17);
+ impl_xoshiro_large!(self);
+ result_plusplus
+ }
+
+ #[inline]
+ fn fill_bytes(&mut self, dest: &mut [u8]) {
+ fill_bytes_via_next(self, dest);
+ }
+
+ #[inline]
+ fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+ self.fill_bytes(dest);
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn reference() {
+ let mut rng = Xoshiro512PlusPlus::from_seed(Seed512(
+ [1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
+ 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0,
+ 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0,
+ 7, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0]));
+ // These values were produced with the reference implementation:
+ // http://xoshiro.di.unimi.it/xoshiro512plusplus.c
+ let expected = [
+ 524291, 1048578, 539099140, 3299073855497, 6917532603230064654,
+ 7494048333530275843, 14418333309547923463, 10960079161595355914,
+ 18279570946505382726, 10209173166699159237,
+ ];
+ for &e in &expected {
+ assert_eq!(rng.next_u64(), e);
+ }
+ }
+}
diff --git a/rand_xoshiro/src/xoshiro512starstar.rs b/rand_xoshiro/src/xoshiro512starstar.rs
index 2db9ac1..8483944 100644
--- a/rand_xoshiro/src/xoshiro512starstar.rs
+++ b/rand_xoshiro/src/xoshiro512starstar.rs
@@ -50,6 +50,19 @@
0x53851efdb6df0aaf, 0x1ebbc8b23eaf25db
]);
}
+
+ /// Jump forward, equivalently to 2^384 calls to `next_u64()`.
+ ///
+ /// This can be used to generate 2^128 starting points, from each of which
+ /// `jump()` will generate 2^128 non-overlapping subsequences for parallel
+ /// distributed computations.
+ pub fn long_jump(&mut self) {
+ impl_jump!(u64, self, [
+ 0x11467fef8f921d28, 0xa2a819f2e79c8ea8, 0xa8299fc284b3959a,
+ 0xb4d347340ca63ee1, 0x1cb0940bedbff6ce, 0xd956c5c4fa1f8e17,
+ 0x915e38fd4eda93bc, 0x5b3ccdfa5d7daca5
+ ]);
+ }
}
diff --git a/utils/ci/script.sh b/utils/ci/script.sh
index 852a850..bd011d5 100644
--- a/utils/ci/script.sh
+++ b/utils/ci/script.sh
@@ -2,23 +2,56 @@
set -ex
+# ----- Options -----
+
+# TARGET enables cross-building
+if [ -z $TARGET ]; then
+ CARGO=cargo
+else
+ CARGO=cross
+ TARGET="--target $TARGET"
+fi
+
+# ALLOC defaults on; is disabled for rustc < 1.36
+if [ -z $ALLOC ]; then
+ ALLOC=1
+fi
+
+# NIGHTLY defaults off
+
+
+# ----- Script -----
+
main() {
- cross test --target $TARGET --tests --no-default-features
- # TODO: add simd_support feature:
- cross test --target $TARGET --features=log
- cross test --target $TARGET --examples
- cross test --target $TARGET --manifest-path rand_core/Cargo.toml
- cross test --target $TARGET --manifest-path rand_core/Cargo.toml --features=serde1
- cross test --target $TARGET --manifest-path rand_core/Cargo.toml --no-default-features
- cross test --target $TARGET --manifest-path rand_distr/Cargo.toml
- cross test --target $TARGET --manifest-path rand_isaac/Cargo.toml --features=serde1
- cross test --target $TARGET --manifest-path rand_pcg/Cargo.toml --features=serde1
- cross test --target $TARGET --manifest-path rand_xorshift/Cargo.toml --features=serde1
- cross test --target $TARGET --manifest-path rand_xoshiro/Cargo.toml --features=serde1
- cross test --target $TARGET --manifest-path rand_chacha/Cargo.toml
- cross test --target $TARGET --manifest-path rand_hc/Cargo.toml
- cross test --target $TARGET --manifest-path rand_os/Cargo.toml
- cross test --target $TARGET --manifest-path rand_jitter/Cargo.toml
+ if [ "0$NIGHTLY" -ge 1 ]; then
+ $CARGO test $TARGET --all-features
+ $CARGO test $TARGET --benches --features=nightly
+ else
+ # all stable features:
+ $CARGO test $TARGET --features=serde1,log,small_rng
+ fi
+
+ if [ "$ALLOC" -ge 1 ]; then
+ $CARGO test $TARGET --tests --no-default-features --features=alloc,getrandom,small_rng
+ $CARGO test $TARGET --manifest-path rand_core/Cargo.toml --no-default-features --features=alloc
+ fi
+
+ $CARGO test $TARGET --tests --no-default-features
+ $CARGO test $TARGET --examples
+
+ $CARGO test $TARGET --manifest-path rand_core/Cargo.toml
+ $CARGO test $TARGET --manifest-path rand_core/Cargo.toml --no-default-features
+ $CARGO test $TARGET --manifest-path rand_core/Cargo.toml --no-default-features --features=getrandom
+
+ $CARGO test $TARGET --manifest-path rand_distr/Cargo.toml
+ $CARGO test $TARGET --manifest-path rand_isaac/Cargo.toml --features=serde1
+ $CARGO test $TARGET --manifest-path rand_pcg/Cargo.toml --features=serde1
+ $CARGO test $TARGET --manifest-path rand_xorshift/Cargo.toml --features=serde1
+ $CARGO test $TARGET --manifest-path rand_xoshiro/Cargo.toml
+ $CARGO test $TARGET --manifest-path rand_chacha/Cargo.toml
+ $CARGO test $TARGET --manifest-path rand_hc/Cargo.toml
+ $CARGO test $TARGET --manifest-path rand_jitter/Cargo.toml
+ $CARGO test $TARGET --manifest-path rand_os/Cargo.toml
}
# we don't run the "test phase" when doing deploys
