| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.commons.rng.core.source64; |
| |
| import org.apache.commons.rng.JumpableUniformRandomProvider; |
| import org.apache.commons.rng.LongJumpableUniformRandomProvider; |
| import org.apache.commons.rng.UniformRandomProvider; |
| import org.apache.commons.rng.core.util.NumberFactory; |
| |
| /** |
| * This abstract class is a base for algorithms from the Xor-Shift-Rotate family of 64-bit |
| * generators with 256-bits of state. |
| * |
| * @see <a href="http://xoshiro.di.unimi.it/">xorshiro / xoroshiro generators</a> |
| * @since 1.3 |
| */ |
| abstract class AbstractXoShiRo256 extends LongProvider implements LongJumpableUniformRandomProvider { |
| /** Size of the state vector. */ |
| private static final int SEED_SIZE = 4; |
| /** The coefficients for the jump function. */ |
| private static final long[] JUMP_COEFFICIENTS = { |
| 0x180ec6d33cfd0abaL, 0xd5a61266f0c9392cL, 0xa9582618e03fc9aaL, 0x39abdc4529b1661cL |
| }; |
| /** The coefficients for the long jump function. */ |
| private static final long[] LONG_JUMP_COEFFICIENTS = { |
| 0x76e15d3efefdcbbfL, 0xc5004e441c522fb3L, 0x77710069854ee241L, 0x39109bb02acbe635L |
| }; |
| |
| // State is maintained using variables rather than an array for performance |
| |
| /** State 0 of the generator. */ |
| protected long state0; |
| /** State 1 of the generator. */ |
| protected long state1; |
| /** State 2 of the generator. */ |
| protected long state2; |
| /** State 3 of the generator. */ |
| protected long state3; |
| |
| /** |
| * Creates a new instance. |
| * |
| * @param seed Initial seed. |
| * If the length is larger than 4, only the first 4 elements will |
| * be used; if smaller, the remaining elements will be automatically |
| * set. A seed containing all zeros will create a non-functional generator. |
| */ |
| AbstractXoShiRo256(long[] seed) { |
| if (seed.length < SEED_SIZE) { |
| final long[] state = new long[SEED_SIZE]; |
| fillState(state, seed); |
| setState(state); |
| } else { |
| setState(seed); |
| } |
| } |
| |
| /** |
| * Creates a new instance using a 4 element seed. |
| * A seed containing all zeros will create a non-functional generator. |
| * |
| * @param seed0 Initial seed element 0. |
| * @param seed1 Initial seed element 1. |
| * @param seed2 Initial seed element 2. |
| * @param seed3 Initial seed element 3. |
| */ |
| AbstractXoShiRo256(long seed0, long seed1, long seed2, long seed3) { |
| state0 = seed0; |
| state1 = seed1; |
| state2 = seed2; |
| state3 = seed3; |
| } |
| |
| /** |
| * Creates a copy instance. |
| * |
| * @param source Source to copy. |
| */ |
| protected AbstractXoShiRo256(AbstractXoShiRo256 source) { |
| super(source); |
| state0 = source.state0; |
| state1 = source.state1; |
| state2 = source.state2; |
| state3 = source.state3; |
| } |
| |
| /** |
| * Copies the state from the array into the generator state. |
| * |
| * @param state the new state |
| */ |
| private void setState(long[] state) { |
| state0 = state[0]; |
| state1 = state[1]; |
| state2 = state[2]; |
| state3 = state[3]; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected byte[] getStateInternal() { |
| return composeStateInternal(NumberFactory.makeByteArray( |
| new long[] {state0, state1, state2, state3}), |
| super.getStateInternal()); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected void setStateInternal(byte[] s) { |
| final byte[][] c = splitStateInternal(s, SEED_SIZE * 8); |
| |
| setState(NumberFactory.makeLongArray(c[0])); |
| |
| super.setStateInternal(c[1]); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public long next() { |
| final long result = nextOutput(); |
| |
| final long t = state1 << 17; |
| |
| state2 ^= state0; |
| state3 ^= state1; |
| state1 ^= state2; |
| state0 ^= state3; |
| |
| state2 ^= t; |
| |
| state3 = Long.rotateLeft(state3, 45); |
| |
| return result; |
| } |
| |
| /** |
| * Use the current state to compute the next output from the generator. |
| * The output function shall vary with respect to different generators. |
| * This method is called from {@link #next()} before the current state is updated. |
| * |
| * @return the next output |
| */ |
| protected abstract long nextOutput(); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p>The jump size is the equivalent of 2<sup>128</sup> |
| * calls to {@link UniformRandomProvider#nextLong() nextLong()}. It can provide |
| * up to 2<sup>128</sup> non-overlapping subsequences.</p> |
| */ |
| @Override |
| public UniformRandomProvider jump() { |
| final UniformRandomProvider copy = copy(); |
| performJump(JUMP_COEFFICIENTS); |
| return copy; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * <p>The jump size is the equivalent of 2<sup>192</sup> calls to |
| * {@link UniformRandomProvider#nextLong() nextLong()}. It can provide up to |
| * 2<sup>64</sup> non-overlapping subsequences of length 2<sup>192</sup>; each |
| * subsequence can provide up to 2<sup>64</sup> non-overlapping subsequences of |
| * length 2<sup>128</sup> using the {@link #jump()} method.</p> |
| */ |
| @Override |
| public JumpableUniformRandomProvider longJump() { |
| final JumpableUniformRandomProvider copy = copy(); |
| performJump(LONG_JUMP_COEFFICIENTS); |
| return copy; |
| } |
| |
| /** |
| * Create a copy. |
| * |
| * @return the copy |
| */ |
| protected abstract AbstractXoShiRo256 copy(); |
| |
| /** |
| * Perform the jump to advance the generator state. Resets the cached state of the generator. |
| * |
| * @param jumpCoefficients Jump coefficients. |
| */ |
| private void performJump(long[] jumpCoefficients) { |
| long s0 = 0; |
| long s1 = 0; |
| long s2 = 0; |
| long s3 = 0; |
| for (final long jc : jumpCoefficients) { |
| for (int b = 0; b < 64; b++) { |
| if ((jc & (1L << b)) != 0) { |
| s0 ^= state0; |
| s1 ^= state1; |
| s2 ^= state2; |
| s3 ^= state3; |
| } |
| next(); |
| } |
| } |
| state0 = s0; |
| state1 = s1; |
| state2 = s2; |
| state3 = s3; |
| resetCachedState(); |
| } |
| } |