Struct Sub

pub struct Sub<A, B> {
    pub lhs: A,
    pub rhs: B,
}

Subtracts one output value from the other.

Fields

lhs: A

rhs: B

Trait Implementations

impl<A: Clone, B: Clone> Clone for Sub<A, B>

fn clone(&self) -> Sub<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Sub<A, B>

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

Formats the value using the given formatter.

impl<A: Hash, B: Hash> Hash for Sub<A, B>

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<A, B> Noise for Sub<A, B>

fn sample2<Point>(&self, point: Point) -> f32

where Self: Sized + Sample<2>, Point: Into<[f32; 2]>,

Samples the noise in 2D.

fn sample3<Point>(&self, point: Point) -> f32

where Self: Sized + Sample<3>, Point: Into<[f32; 3]>,

Samples the noise in 3D.

fn sample4<Point>(&self, point: Point) -> f32

where Self: Sized + Sample<4>, Point: Into<[f32; 4]>,

Samples the noise in 3D.

fn sample2a<Point>(&self, point: Point) -> f32

where Self: Sized + Sample<2, f32x2>, Point: Into<f32x2>,

Available on crate feature nightly-simd only.

Samples the noise in 2D.

fn sample3a<Point>(&self, point: Point) -> f32

where Self: Sized + Sample<3, f32x4>, Point: Into<f32x4>,

Available on crate feature nightly-simd only.

Samples the noise in 3D.

fn sample4a<Point>(&self, point: Point) -> f32

where Self: Sized + Sample<4, f32x4>, Point: Into<f32x4>,

Available on crate feature nightly-simd only.

Samples the noise in 4D.

fn seed(self, seed: i32) -> Seeded<Self>

where Self: Sized,

Overwrites the seed to be sampled with.

fn add_seed(self, value: i32) -> AddSeed<Self>

where Self: Sized,

Adds value to the seed.

fn mul_seed(self, value: i32) -> MulSeed<Self>

where Self: Sized,

Multiplies the seed by value.

fn frequency<F>(self, frequency: F) -> Frequency<Self, F::Noise>

where Self: Sized, F: ValueOrNoise,

Modifies a noise with a frequency multiplier.

fn fbm(self, octaves: u32, gain: f32, lacunarity: f32) -> Fbm<Self>

where Self: Sized,

Creates a fractal from this noise with the provided octaves, gain and lacunarity.

fn ridged(self) -> Ridged<Self>

where Self: Sized,

Modifies a noise to create a peak at 0.

fn triangle_wave<F>(self, frequency: F) -> TriangleWave<Self, F::Noise>

where Self: Sized, F: ValueOrNoise,

Applies a triangle wave to the output of a noise function.

fn tileable(self, width: f32, height: f32) -> Tileable<Self>

where Self: Sized,

Creates a tileable 2D noise from a 4D noise.

fn translate_x<X>(self, x: X) -> TranslateX<Self, X::Noise>

where Self: Sized, X: ValueOrNoise,

Translates the point before it is used to sample self.

fn translate_xy<X, Y>(self, x: X, y: Y) -> TranslateXy<Self, X::Noise, Y::Noise>

where Self: Sized, X: ValueOrNoise, Y: ValueOrNoise,

Translates the point before it is used to sample self.

fn translate_xyz<X, Y, Z>( self, x: X, y: Y, z: Z, ) -> TranslateXyz<Self, X::Noise, Y::Noise, Z::Noise>

where Self: Sized, X: ValueOrNoise, Y: ValueOrNoise, Z: ValueOrNoise,

Translates the point before it is used to sample self.

fn translate_xyzw<X, Y, Z, W>( self, x: X, y: Y, z: Z, w: W, ) -> TranslateXyzw<Self, X::Noise, Y::Noise, Z::Noise, W::Noise>

where Self: Sized, X: ValueOrNoise, Y: ValueOrNoise, Z: ValueOrNoise, W: ValueOrNoise,

Translates the point before it is used to sample self.

fn add<Rhs>(self, rhs: Rhs) -> Add<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Adds the output values.

fn sub<Rhs>(self, rhs: Rhs) -> Sub<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Subtracts one output value from the other.

fn mul<Rhs>(self, rhs: Rhs) -> Mul<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Multiplies the output values.

fn div<Rhs>(self, rhs: Rhs) -> Div<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Divides one output value by the other.

fn rem<Rhs>(self, rhs: Rhs) -> Rem<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Calculates the remainder from dividing one output value by the other.

fn min<Rhs>(self, rhs: Rhs) -> Min<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Computes the minimum of the two output values.

fn max<Rhs>(self, rhs: Rhs) -> Max<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Computes the maximum of the two output values.

fn clamp<Min, Max>( self, min: Min, max: Max, ) -> Clamp<Self, Min::Noise, Max::Noise>

where Self: Sized, Min: ValueOrNoise, Max: ValueOrNoise,

Returns max if value is greater than max and min if value is less than min. Otherwise this will return value.

fn lerp<B, T>(self, b: B, t: T) -> Lerp<Self, B::Noise, T::Noise>

where Self: Sized, B: ValueOrNoise, T: ValueOrNoise,

Linearly interpolates between self and b.

fn pow<Rhs>(self, rhs: Rhs) -> Pow<Self, Rhs::Noise>

where Self: Sized, Rhs: ValueOrNoise,

Raises the output value to a power.

fn neg(self) -> Neg<Self>

where Self: Sized,

Performs negation on the output value.

fn abs(self) -> Abs<Self>

where Self: Sized,

Computes the absolute value of the output value.

fn sqrt(self) -> Sqrt<Self>

where Self: Sized,

Returns the square root of a number.

fn floor(self) -> Floor<Self>

where Self: Sized,

Computes the largest integer less than or equal to the output value.

fn ceil(self) -> Ceil<Self>

where Self: Sized,

Computes the smallest integer greater than or equal to self.

fn round(self) -> Round<Self>

where Self: Sized,

Computes the nearest integer to the output value. If a value is half-way between two integers, round away from 0.0.

fn sin(self) -> Sin<Self>

where Self: Sized,

Computes the sine of the output value (in radians).

fn cos(self) -> Cos<Self>

where Self: Sized,

Computes the cosine of the output value (in radians).

fn tan(self) -> Tan<Self>

where Self: Sized,

Computes the tangent of the output value (in radians).

fn map<F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: Fn(f32) -> f32,

Maps the output value.

fn by_ref(&self) -> &Self

where Self: Sized,

Returns the Noise by reference.

impl<A: PartialEq, B: PartialEq> PartialEq for Sub<A, B>

fn eq(&self, other: &Sub<A, B>) -> 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<const DIM: usize, A, B> Sample<DIM> for Sub<A, B>

where A: Sample<DIM>, B: Sample<DIM>,

fn sample_with_seed(&self, point: [f32; DIM], seed: i32) -> f32

impl<const DIM: usize, const LANES: usize, A, B> Sample<DIM, Simd<f32, LANES>> for Sub<A, B>

where A: Sample<DIM, Simd<f32, LANES>>, B: Sample<DIM, Simd<f32, LANES>>, LaneCount<LANES>: SupportedLaneCount,

Available on crate feature nightly-simd only.

fn sample_with_seed(&self, point: Simd<f32, LANES>, seed: i32) -> f32

impl<A: Copy, B: Copy> Copy for Sub<A, B>

impl<A: Eq, B: Eq> Eq for Sub<A, B>

impl<A, B> StructuralPartialEq for Sub<A, B>