Struct R2 

pub struct R2 { /* private fields */ }

R2 low-discrepancy sequence for improved distribution.

Provides better spatial coverage than random sequences. Based on the generalized golden ratio (1.32471…). Produces visually pleasing patterns with minimal clustering or gaps.

Implementations

impl R2

pub fn new(seed: u32) -> Self

Trait Implementations

impl Clone for R2

fn clone(&self) -> R2

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for R2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for R2

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LinearRng for R2

fn new(seed: u32) -> Self

Create a new linear RNG with the given seed.

fn compute(&self, index: u32) -> f32

Compute dither offset for a given index. Returns a value in range [-1, 1] to be scaled by amplitude.

fn dither<T>( &self, value: T, min: T, one: T, dither_amplitude: T, index: u32, ) -> T

where T: DitherFloat, Self: Sized,

Dither a single value.

fn simple_dither<T>(&self, value: T, one: T, index: u32) -> T

where T: DitherFloat + Number + CastableFrom<f32>, Self: Sized,

Simple dither for a single value.

fn dither_slice<T>(&self, values: &mut [T], min: T, one: T, dither_amplitude: T)

where T: DitherFloat + Send + Sync, Self: Sized,

Dither values in a slice (parallel version).

fn simple_dither_slice<T>(&self, values: &mut [T], one: T)

where T: DitherFloat + Number + CastableFrom<f32> + Send + Sync, Self: Sized,

Simple dither for values in a slice (parallel version).

fn dither_iter<T, I>( &self, values: I, min: T, one: T, dither_amplitude: T, ) -> Vec<T>

where T: DitherFloat + Send + Sync, I: IntoIterator<Item = T>, I::IntoIter: Send, Self: Sized,

Dither values from an iterator (parallel version).

fn simple_dither_iter<T, I>(&self, values: I, one: T) -> Vec<T>

where T: DitherFloat + Number + CastableFrom<f32> + Send + Sync, I: IntoIterator<Item = T>, I::IntoIter: Send, Self: Sized,

Simple dither for values from an iterator (parallel version).

fn dither_float<Src, Dest>(&self, value: Src, index: u32) -> Dest

where Src: DitherFloatConversion<Dest> + DitherFloat + CastableFrom<f64>, Self: Sized,

Dither a float value when converting to lower precision.

fn dither_float_slice<Src, Dest>(&self, values: &[Src]) -> Vec<Dest>

where Src: DitherFloatConversion<Dest> + DitherFloat + CastableFrom<f64> + Copy + Send + Sync, Dest: Send, Self: Sized,

Dither float values in a slice when converting to lower precision (parallel version).

fn dither_float_iter<Src, Dest, I>(&self, values: I) -> Vec<Dest>

where Src: DitherFloatConversion<Dest> + DitherFloat + CastableFrom<f64> + Send + Sync, Dest: Send, I: IntoIterator<Item = Src>, I::IntoIter: Send, Self: Sized,

Dither float values from an iterator when converting to lower precision (parallel version).

impl PartialEq for R2

fn eq(&self, other: &R2) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for R2

impl Eq for R2

impl StructuralPartialEq for R2