Searched defs:seed (Results 1 - 17 of 17) sorted by relevance

/libcore/ojluni/src/main/java/java/security/
H A DSecureRandomSpi.java45 * Reseeds this random object. The given seed supplements, rather than
46 * replaces, the existing seed. Thus, repeated calls are guaranteed
49 * @param seed the seed.
51 protected abstract void engineSetSeed(byte[] seed); argument
58 * to seed itself. This self-seeding will not occur if
66 * Returns the given number of seed bytes. This call may be used to
67 * seed other random number generators.
69 * @param numBytes the number of seed bytes to generate.
71 * @return the seed byte
[all...]
H A DSecureRandom.java48 * Therefore any seed material passed to a SecureRandom object must be
63 * to produce a pseudo-random sequence from a true random seed.
77 * to generate a given number of seed bytes (to seed other random number
80 * byte seed[] = random.generateSeed(20);
158 * <p> The returned SecureRandom object has not been seeded. To seed the
161 * {@code nextBytes} will force the SecureRandom object to seed itself.
178 * The SecureRandom instance is seeded with the specified seed bytes.
196 * @param seed the seed
198 SecureRandom(byte seed[]) argument
203 getDefaultPRNG(boolean setSeed, byte[] seed) argument
435 setSeed(byte[] seed) argument
453 setSeed(long seed) argument
[all...]
/libcore/benchmarks/src/benchmarks/
H A DXmlSerializeBenchmark.java34 int seed; field in class:XmlSerializeBenchmark
40 private void serializeRandomXml(Constructor<? extends XmlSerializer> ctor, long seed) argument
54 Random r = new Random(seed);
98 serializeRandomXml(ctor, seed);
/libcore/luni/src/test/java/org/apache/harmony/security/tests/java/security/
H A DSecureRandomSpiTest.java52 protected void engineSetSeed(byte[] seed) {} argument
/libcore/support/src/test/java/org/apache/harmony/security/tests/support/
H A DRandomImpl.java36 protected void engineSetSeed(byte[] seed) { argument
/libcore/ojluni/src/main/java/java/security/spec/
H A DEllipticCurve.java48 private final byte[] seed; field in class:EllipticCurve
89 * {@code b}, and the {@code seed} used for curve generation.
93 * @param seed the bytes used during curve generation for later
102 BigInteger b, byte[] seed) {
117 if (seed != null) {
118 this.seed = seed.clone();
120 this.seed = null;
153 * Returns the seeding bytes {@code seed} used
155 * @return the seeding bytes {@code seed}
101 EllipticCurve(ECField field, BigInteger a, BigInteger b, byte[] seed) argument
[all...]
/libcore/luni/src/test/java/tests/security/spec/
H A DEllipticCurveTest.java47 byte[] seed = new byte[24];
49 new EllipticCurve(f, a, b, seed);
56 new EllipticCurve(f1, a, b, seed);
59 // the seed parameter may be null
63 seed = null;
65 new EllipticCurve(f, a, b, seed);
81 byte[] seed = new byte[24];
85 new EllipticCurve(f, a, b, seed);
93 seed = new byte[24];
96 new EllipticCurve(f, a, b, seed);
644 MyEllipticCurve(ECField f, BigInteger a, BigInteger b, byte[] seed) argument
[all...]
/libcore/ojluni/src/main/java/java/util/stream/
H A DReduceOps.java61 * @param seed the identity element for the reduction
69 makeRef(U seed, BiFunction<U, ? super T, U> reducer, BinaryOperator<U> combiner) { argument
75 state = seed;
H A DDoubleStream.java759 * application of a function {@code f} to an initial element {@code seed},
760 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
761 * {@code f(f(seed))}, etc.
764 * will be the provided {@code seed}. For {@code n > 0}, the element at
768 * @param seed the initial element
773 public static DoubleStream iterate(final double seed, final DoubleUnaryOperator f) { argument
776 double t = seed;
H A DStream.java1002 * application of a function {@code f} to an initial element {@code seed},
1003 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
1004 * {@code f(f(seed))}, etc.
1007 * the provided {@code seed}. For {@code n > 0}, the element at position
1012 * @param seed the initial element
1017 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) { argument
1030 return t = (t == Streams.NONE) ? seed : f.apply(t);
H A DIntStream.java727 * application of a function {@code f} to an initial element {@code seed},
728 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
729 * {@code f(f(seed))}, etc.
732 * the provided {@code seed}. For {@code n > 0}, the element at position
736 * @param seed the initial element
741 public static IntStream iterate(final int seed, final IntUnaryOperator f) { argument
744 int t = seed;
H A DLongStream.java719 * application of a function {@code f} to an initial element {@code seed},
720 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
721 * {@code f(f(seed))}, etc.
724 * be the provided {@code seed}. For {@code n > 0}, the element at position
728 * @param seed the initial element
733 public static LongStream iterate(final long seed, final LongUnaryOperator f) { argument
736 long t = seed;
/libcore/ojluni/src/main/java/java/util/
H A DRandom.java41 * pseudorandom numbers. The class uses a 48-bit seed, which is
46 * seed, and the same sequence of method calls is made for each, they
86 private final AtomicLong seed; field in class:Random
101 * the seed of the random number generator to a value very likely
123 * Creates a new random number generator using a single {@code long} seed.
124 * The seed is the initial value of the internal state of the pseudorandom
127 * <p>The invocation {@code new Random(seed)} is equivalent to:
130 * rnd.setSeed(seed);}</pre>
132 * @param seed the initial seed
135 Random(long seed) argument
145 initialScramble(long seed) argument
168 setSeed(long seed) argument
[all...]
H A DSplittableRandom.java82 * seed unless the {@linkplain System#getProperty system property}
102 * constant ("gamma") to the current (64 bit) seed, forming a
103 * simple sequence. The seed and the gamma values for any two
107 * sequence (seed) values, but instead a hash-like bit-mix of
117 * The split operation uses the current generator to form the seed
119 * avoid potential correlations between seed and value generation,
140 * manner, so we use an AtomicLong to represent the seed rather
142 * defaultGen, we start off using a seed based on current time
170 * The seed. Updated only via method nextSeed.
172 private long seed; field in class:SplittableRandom
182 SplittableRandom(long seed, long gamma) argument
367 SplittableRandom(long seed) argument
[all...]
/libcore/ojluni/src/main/java/java/lang/
H A DMath.java763 * Set the seed for the pseudo random generator used by {@link #random()}
768 public static void setRandomSeedInternal(long seed) { argument
769 RandomNumberGeneratorHolder.randomNumberGenerator.setSeed(seed);
/libcore/ojluni/src/main/java/java/util/concurrent/
H A DThreadLocalRandom.java55 * with an internally generated seed that may not otherwise be
76 * seed unless the {@linkplain System#getProperty system property}
93 * simpler (xorShift) random seed that is conservatively used to
153 * thread local seed value needs to be generated. Note that even
160 long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
162 U.putLong(t, SEED, seed);
183 public void setSeed(long seed) { argument
190 Thread t; long r; // read and update per-thread seed
944 * Returns the pseudo-randomly initialized or updated secondary seed.
966 * seed fo
[all...]
/libcore/luni/src/test/java/libcore/java/security/
H A DProviderTest.java1208 protected void engineSetSeed(byte[] seed) { argument

Completed in 292 milliseconds