Struct Env 

#[repr(C)]
pub struct Env(pub f64);

A data sample from an envelope, typically holding a value between -1.0 and 1.0.

This is distinguished from Mono, as they have different uses. There shouldn’t be much reason to convert one to the other.

Tuple Fields

0: f64

Implementations

impl Env

pub const fn new(x: f64) -> Self

Initializes a new Env sample.

You can just use Env(x) to the same effect.

pub fn array<const N: usize>(array: [f64; N]) -> [Self; N]

A convenience function to create an array of Env samples.

Trait Implementations

impl Add for Env

type Output = Env

The resulting type after applying the + operator.

fn add(self, rhs: Env) -> Env

Performs the + operation.

impl AddAssign for Env

fn add_assign(&mut self, rhs: Env)

Performs the += operation.

impl Array for Env

Safety: The type is tagged as #[repr(C)].

const SIZE: usize = 2usize

The size of the array.

type Item = f64

The type of items this array stores.

type Array<T> = [T; 1]

The array type with the same number of elements as SIZE.

fn from_array(array: [f64; 1]) -> Self

Creates a value from an array.

fn into_array(self) -> [f64; 1]

Turns this value into an array.

fn from_fn<F: FnMut(usize) -> Self::Item>(f: F) -> Self

Creates the array [f(0), f(1), ...].

fn new_default() -> Self

where Self::Item: Default,

Initializes a new array with default values.

fn get(&self, index: usize) -> Option<&Self::Item>

Gets the value from channel index.

fn get_mut(&mut self, index: usize) -> Option<&mut Self::Item>

Gets a mutable reference to the value from channel index.

fn _index_mut(&mut self, index: usize) -> &mut Self::Item

Currently, rust-analyzer trips up sometimes that &mut self[index] is called directly, complaining that self is immutable. This hack bypasses this.

fn for_each<F: FnMut(usize)>(f: F)

Executes a function for each element in the array type.

fn map<F: FnMut(&Self::Item) -> Self::Item>(&self, f: F) -> Self

Applies a function f to all entries of the sample.

fn map_array<T: Array, F: FnMut(&Self::Item) -> T::Item>(&self, f: F) -> T

Applies a function f to all entries of the sample.

fn map_mut<F: FnMut(&mut Self::Item)>(&mut self, f: F)

Mutably applies a function f to all entries of the sample.

fn pairwise<F: FnMut(&Self::Item, &Self::Item) -> Self::Item>( &self, rhs: Self, f: F, ) -> Self

Applies a function f to pairs of entries of the samples.

fn pairwise_mut<F: FnMut(&mut Self::Item, &Self::Item)>( &mut self, rhs: Self, f: F, )

Mutably applies a function f to pairs of entries of the samples.

fn from_val(val: Self::Item) -> Self

where Self::Item: Copy,

Initializes an array filled with the specified value.

fn _as_ref(&self) -> &[Self::Item]

A default implementation for the AsRef trait.

fn _as_mut(&mut self) -> &mut [Self::Item]

A default implementation for the AsMut trait.

impl AsMut<[f64]> for Env

fn as_mut(&mut self) -> &mut [f64]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[f64]> for Env

fn as_ref(&self) -> &[f64]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Env

fn clone(&self) -> Env

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Env

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

Formats the value using the given formatter.

impl Default for Env

fn default() -> Env

Returns the “default value” for a type.

impl Distribution<Env> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Env

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<__RhsT> Div<__RhsT> for Env

where f64: Div<__RhsT, Output = f64>,

type Output = Env

The resulting type after applying the / operator.

fn div(self, rhs: __RhsT) -> Env

Performs the / operation.

impl<__RhsT> DivAssign<__RhsT> for Env

where f64: DivAssign<__RhsT>,

fn div_assign(&mut self, rhs: __RhsT)

Performs the /= operation.

impl Index<usize> for Env

type Output = f64

The returned type after indexing.

fn index(&self, index: usize) -> &f64

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Env

fn index_mut(&mut self, index: usize) -> &mut f64

Performs the mutable indexing (container[index]) operation.

impl<__RhsT> Mul<__RhsT> for Env

where f64: Mul<__RhsT, Output = f64>,

type Output = Env

The resulting type after applying the * operator.

fn mul(self, rhs: __RhsT) -> Env

Performs the * operation.

impl<__RhsT> MulAssign<__RhsT> for Env

where f64: MulAssign<__RhsT>,

fn mul_assign(&mut self, rhs: __RhsT)

Performs the *= operation.

impl Neg for Env

type Output = Env

The resulting type after applying the - operator.

fn neg(self) -> Env

Performs the unary - operation.

impl PartialEq for Env

fn eq(&self, other: &Env) -> 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 Sample for Env

fn size_u8() -> u8

The size as a u8.

fn fst(&self) -> f64

Gets the value from the first channel.

fn fst_mut(&mut self) -> &mut f64

Gets a mutable reference to the value from the first channel.

fn snd(&self) -> f64

Gets the value from the second channel, defaulting to the first.

fn snd_mut(&mut self) -> &mut f64

Gets a mutable reference to the value from the second channel, defaulting to the first.

fn rand_with<R: Rng + ?Sized>(rng: &mut R) -> Self

Generates a random sample from a given Rng object.

fn rand() -> Self

Generates a random sample.

fn _sum<I: IntoIterator<Item = Self>>(iter: I) -> Self

A default implementation of the Sum trait.

impl SampleBase for Env

const ZERO: Self

The zero value.

impl Sub for Env

type Output = Env

The resulting type after applying the - operator.

fn sub(self, rhs: Env) -> Env

Performs the - operation.

impl SubAssign for Env

fn sub_assign(&mut self, rhs: Env)

Performs the -= operation.

impl Sum for Env

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for Env

impl StructuralPartialEq for Env