Struct blackboxmc_java::util::JavaRandom

#[repr(C)]
pub struct JavaRandom<'mc>(_, _);

An instance of this class is used to generate a stream of pseudorandom numbers. The class uses a 48-bit seed, which is modified using a linear congruential formula. (See Donald Knuth, The Art of Computer Programming, Volume 2, Section 3.2.1.)

If two instances of Random are created with the same seed, and the same sequence of method calls is made for each, they will generate and return identical sequences of numbers. In order to guarantee this property, particular algorithms are specified for the class Random. Java implementations must use all the algorithms shown here for the class Random, for the sake of absolute portability of Java code. However, subclasses of class Random are permitted to use other algorithms, so long as they adhere to the general contracts for all the methods.

The algorithms implemented by class Random use a protected utility method that on each invocation can supply up to 32 pseudorandomly generated bits.

Many applications will find the method Math.random() simpler to use.

Instances of java.util.Random are threadsafe. However, the concurrent use of the same java.util.Random instance across threads may encounter contention and consequent poor performance. Consider instead using ThreadLocalRandom in multithreaded designs.

Instances of java.util.Random are not cryptographically secure. Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.

Implementations

impl<'mc> JavaRandom<'mc>

pub fn new_with_long( jni: &SharedJNIEnv<'mc>, arg0: Option<i64> ) -> Result<JavaRandom<'mc>, Box<dyn Error>>

pub fn next_boolean(&self) -> Result<bool, Box<dyn Error>>

pub fn next_long(&self) -> Result<i64, Box<dyn Error>>

pub fn next_float(&self) -> Result<f32, Box<dyn Error>>

pub fn set_seed(&self, arg0: i64) -> Result<(), Box<dyn Error>>

pub fn next_bytes(&self, arg0: Vec<i8>) -> Result<(), Box<dyn Error>>

pub fn next_gaussian(&self) -> Result<f64, Box<dyn Error>>

pub fn next_double(&self) -> Result<f64, Box<dyn Error>>

pub fn next_int_with_int( &self, arg0: Option<i32> ) -> Result<i32, Box<dyn Error>>

pub fn is_deprecated(&self) -> Result<bool, Box<dyn Error>>

pub fn next_exponential(&self) -> Result<f64, Box<dyn Error>>

pub fn default( jni: &SharedJNIEnv<'mc> ) -> Result<JavaRandomGenerator<'mc>, Box<dyn Error>>

pub fn of( jni: &SharedJNIEnv<'mc>, arg0: impl Into<String> ) -> Result<JavaRandomGenerator<'mc>, Box<dyn Error>>

pub fn instance_of(&self, other: impl Into<String>) -> Result<bool, Error>

Trait Implementations

impl<'mc> Into<JavaRandomGenerator<'mc>> for JavaRandom<'mc>

fn into(self) -> JavaRandomGenerator<'mc>

Converts this type into the (usually inferred) input type.

impl<'mc> JNIInstantiatable<'mc> for JavaRandom<'mc>

fn from_raw( env: &SharedJNIEnv<'mc>, obj: JObject<'mc> ) -> Result<Self, Box<dyn Error>>

impl<'mc> JNIRaw<'mc> for JavaRandom<'mc>

fn jni_ref(&self) -> SharedJNIEnv<'mc>

fn jni_object(&self) -> JObject<'mc>