Struct fundsp::combinator::An

pub struct An<X: AudioNode>(pub X);

AudioNode wrapper that implements operators and traits.

Tuple Fields

0: X

Implementations

impl<X: AudioNode> An<X>

pub fn reset(&mut self)

pub fn set_sample_rate(&mut self, sample_rate: f64)

pub fn tick( &mut self, input: &Frame<X::Sample, X::Inputs> ) -> Frame<X::Sample, X::Outputs>

pub fn process( &mut self, size: usize, input: &[&[X::Sample]], output: &mut [&mut [X::Sample]] )

pub fn route(&mut self, input: &SignalFrame, frequency: f64) -> SignalFrame

pub fn inputs(&self) -> usize

pub fn outputs(&self) -> usize

pub fn set_hash(&mut self, hash: u64)

pub fn ping(&mut self, probe: bool, hash: AttoHash) -> AttoHash

pub fn get_mono(&mut self) -> X::Sample

pub fn get_stereo(&mut self) -> (X::Sample, X::Sample)

pub fn filter_mono(&mut self, x: X::Sample) -> X::Sample

pub fn filter_stereo( &mut self, x: X::Sample, y: X::Sample ) -> (X::Sample, X::Sample)

Trait Implementations

impl<X> Add<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the + operator.

fn add(self, y: An<X>) -> Self::Output

Performs the + operation.

impl<X> Add<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the + operator.

fn add(self, y: An<X>) -> Self::Output

Performs the + operation.

impl<X> Add<An<X>> for f32

where X: AudioNode<Sample = f32>, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

constant + X binary operator: Adds constant to outputs of X. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f32, X, FrameAddScalar<<X as AudioNode>::Outputs, f32>>>

The resulting type after applying the + operator.

fn add(self, y: An<X>) -> Self::Output

Performs the + operation.

impl<X> Add<An<X>> for f64

where X: AudioNode<Sample = f64>, X::Inputs: Size<f64>, X::Outputs: Size<f64>,

constant + X binary operator: Adds constant to outputs of X. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f64, X, FrameAddScalar<<X as AudioNode>::Outputs, f64>>>

The resulting type after applying the + operator.

fn add(self, y: An<X>) -> Self::Output

Performs the + operation.

impl<X, Y> Add<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Sample = X::Sample, Outputs = X::Outputs>, X::Inputs: Size<X::Sample> + Add<Y::Inputs>, Y::Inputs: Size<Y::Sample>, <X::Inputs as Add<Y::Inputs>>::Output: Size<X::Sample>,

+ binary operator: Sums outputs of two nodes with disjoint inputs. The nodes must have the same number of outputs.

type Output = An<Binop<<X as AudioNode>::Sample, FrameAdd<<X as AudioNode>::Outputs, <X as AudioNode>::Sample>, X, Y>>

The resulting type after applying the + operator.

fn add(self, y: An<Y>) -> Self::Output

Performs the + operation.

impl<X> Add<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the + operator.

fn add(self, y: Net32) -> Self::Output

Performs the + operation.

impl<X> Add<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the + operator.

fn add(self, y: Net64) -> Self::Output

Performs the + operation.

impl<X> Add<f32> for An<X>

where X: AudioNode<Sample = f32>, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

X + constant binary operator: Adds constant to outputs of X. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f32, X, FrameAddScalar<<X as AudioNode>::Outputs, <X as AudioNode>::Sample>>>

The resulting type after applying the + operator.

fn add(self, y: f32) -> Self::Output

Performs the + operation.

impl<X> Add<f64> for An<X>

where X: AudioNode<Sample = f64>, X::Inputs: Size<f64>, X::Outputs: Size<f64>,

X + constant binary operator: Adds constant to outputs of X. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f64, X, FrameAddScalar<<X as AudioNode>::Outputs, <X as AudioNode>::Sample>>>

The resulting type after applying the + operator.

fn add(self, y: f64) -> Self::Output

Performs the + operation.

impl<X: AudioNode<Sample = f32> + Sync + Send> AudioUnit32 for An<X>

where X::Inputs: Size<f32>, X::Outputs: Size<f32>,

fn reset(&mut self)

Reset the input state of the unit to an initial state where it has not processed any data. In other words, reset time to zero.

fn set_sample_rate(&mut self, sample_rate: f64)

Set the sample rate of the unit. The default sample rate is 44100 Hz. The unit is allowed to reset itself here in response to sample rate changes. If the sample rate stays unchanged, then the goal is to maintain current state.

fn tick(&mut self, input: &[f32], output: &mut [f32])

Process one sample. The length of input and output must be equal to inputs and outputs, respectively.

fn process(&mut self, size: usize, input: &[&[f32]], output: &mut [&mut [f32]])

Process up to 64 (MAX_BUFFER_SIZE) samples. Buffers are supplied as slices. All buffers must have room for at least size samples. If size is zero then this is a no-op, which is permitted. The number of input and output buffers must be equal to inputs and outputs, respectively.

fn inputs(&self) -> usize

Number of inputs to this unit. Equals size of the input argument in tick and process. This should be fixed after construction.

fn outputs(&self) -> usize

Number of outputs from this unit. Equals size of the output argument in tick and process. This should be fixed after construction.

fn get_id(&self) -> u64

Return an ID code for this type of unit.

fn set_hash(&mut self, hash: u64)

Set unit pseudorandom phase hash. Override this to use the hash. This is called from ping (only). It should not be called by users. The default implementation does nothing.

fn ping(&mut self, probe: bool, hash: AttoHash) -> AttoHash

Ping contained AudioUnits and AudioNodes to obtain a deterministic pseudorandom hash. The local hash includes children, too. Leaf nodes should not need to override this. If probe is true, then this is a probe for computing the network hash and set_hash should not be called yet. To set a custom hash for a graph, call this method with ping set to false and hash initialized with the custom hash.

fn route(&mut self, input: &SignalFrame, frequency: f64) -> SignalFrame

Route constants, latencies and frequency responses at frequency Hz from inputs to outputs. Return output signal.

fn footprint(&self) -> usize

Memory footprint of this unit in bytes, without counting buffers and other allocations.

fn allocate(&mut self)

Preallocate all needed memory, including buffers for block processing. The default implementation does nothing.

fn response(&mut self, output: usize, frequency: f64) -> Option<Complex64>

Evaluate frequency response of output at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn response_db(&mut self, output: usize, frequency: f64) -> Option<f64>

Evaluate frequency response of output in dB at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn latency(&mut self) -> Option<f64>

Causal latency in (fractional) samples. After a reset, we can discard this many samples from the output to avoid incurring a pre-delay. The latency may depend on the sample rate.

fn get_mono(&mut self) -> f32

Retrieve the next mono sample from a generator. The node must have no inputs and 1 or 2 outputs. If there are two outputs, average them.

fn get_stereo(&mut self) -> (f32, f32)

Retrieve the next stereo sample (left, right) from a generator. The node must have no inputs and 1 or 2 outputs. If there is just one output, duplicate it.

fn filter_mono(&mut self, x: f32) -> f32

Filter the next mono sample x. The node must have exactly 1 input and 1 output.

fn filter_stereo(&mut self, x: f32, y: f32) -> (f32, f32)

Filter the next stereo sample (x, y). The node must have exactly 2 inputs and 2 outputs.

fn display(&mut self) -> String

Print information about this unit into a string.

impl<X: AudioNode<Sample = f64> + Sync + Send> AudioUnit64 for An<X>

where X::Inputs: Size<f64>, X::Outputs: Size<f64>,

fn reset(&mut self)

Reset the input state of the unit to an initial state where it has not processed any data. In other words, reset time to zero.

fn set_sample_rate(&mut self, sample_rate: f64)

Set the sample rate of the unit. The default sample rate is 44100 Hz. The unit is allowed to reset itself here in response to sample rate changes. If the sample rate stays unchanged, then the goal is to maintain current state.

fn tick(&mut self, input: &[f64], output: &mut [f64])

Process one sample. The length of input and output must be equal to inputs and outputs, respectively.

fn process(&mut self, size: usize, input: &[&[f64]], output: &mut [&mut [f64]])

Process up to 64 (MAX_BUFFER_SIZE) samples. Buffers are supplied as slices. All buffers must have room for at least size samples. If size is zero then this is a no-op, which is permitted. The number of input and output buffers must be equal to inputs and outputs, respectively.

fn inputs(&self) -> usize

Number of inputs to this unit. Equals size of the input argument in tick and process. This should be fixed after construction.

fn outputs(&self) -> usize

Number of outputs from this unit. Equals size of the output argument in tick and process. This should be fixed after construction.

fn get_id(&self) -> u64

Return an ID code for this type of unit.

fn set_hash(&mut self, hash: u64)

Set unit pseudorandom phase hash. Override this to use the hash. This is called from ping (only). It should not be called by users. The default implementation does nothing.

fn ping(&mut self, probe: bool, hash: AttoHash) -> AttoHash

Ping contained AudioUnits and AudioNodes to obtain a deterministic pseudorandom hash. The local hash includes children, too. Leaf nodes should not need to override this. If probe is true, then this is a probe for computing the network hash and set_hash should not be called yet. To set a custom hash for a graph, call this method with ping set to false and hash initialized with the custom hash.

fn route(&mut self, input: &SignalFrame, frequency: f64) -> SignalFrame

Route constants, latencies and frequency responses at frequency Hz from inputs to outputs. Return output signal.

fn footprint(&self) -> usize

Memory footprint of this unit in bytes, without counting buffers and other allocations.

fn allocate(&mut self)

Preallocate all needed memory, including buffers for block processing. The default implementation does nothing.

fn response(&mut self, output: usize, frequency: f64) -> Option<Complex64>

Evaluate frequency response of output at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn response_db(&mut self, output: usize, frequency: f64) -> Option<f64>

Evaluate frequency response of output in dB at frequency Hz. Any linear response can be composed. Return None if there is no response or it could not be calculated.

fn latency(&mut self) -> Option<f64>

Causal latency in (fractional) samples. After a reset, we can discard this many samples from the output to avoid incurring a pre-delay. The latency may depend on the sample rate.

fn get_mono(&mut self) -> f64

Retrieve the next mono sample from a generator. The node must have no inputs and 1 or 2 outputs. If there are two outputs, average them.

fn get_stereo(&mut self) -> (f64, f64)

Retrieve the next stereo sample (left, right) from a generator. The node must have no inputs and 1 or 2 outputs. If there is just one output, duplicate it.

fn filter_mono(&mut self, x: f64) -> f64

Filter the next mono sample x. The node must have exactly 1 input and 1 output.

fn filter_stereo(&mut self, x: f64, y: f64) -> (f64, f64)

Filter the next stereo sample (x, y). The node must have exactly 2 inputs and 2 outputs.

fn display(&mut self) -> String

Print information about this unit into a string.

impl<X> BitAnd<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the & operator.

fn bitand(self, y: An<X>) -> Self::Output

Performs the & operation.

impl<X> BitAnd<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the & operator.

fn bitand(self, y: An<X>) -> Self::Output

Performs the & operation.

impl<T, X, Y> BitAnd<An<Y>> for An<X>

where T: Float, X: AudioNode<Sample = T>, Y: AudioNode<Sample = T, Inputs = X::Inputs, Outputs = X::Outputs>, Y::Inputs: Size<T>, Y::Outputs: Size<T>,

& binary operator: The bus operator mixes together units with similar connectivity that share inputs and outputs.

type Output = An<Bus<T, X, Y>>

The resulting type after applying the & operator.

fn bitand(self, y: An<Y>) -> Self::Output

Performs the & operation.

impl<X> BitAnd<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the & operator.

fn bitand(self, y: Net32) -> Self::Output

Performs the & operation.

impl<X> BitAnd<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the & operator.

fn bitand(self, y: Net64) -> Self::Output

Performs the & operation.

impl<X> BitOr<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the | operator.

fn bitor(self, y: An<X>) -> Self::Output

Performs the | operation.

impl<X> BitOr<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the | operator.

fn bitor(self, y: An<X>) -> Self::Output

Performs the | operation.

impl<T, X, Y> BitOr<An<Y>> for An<X>

where T: Float, X: AudioNode<Sample = T>, Y: AudioNode<Sample = T>, X::Inputs: Size<T> + Add<Y::Inputs>, X::Outputs: Size<T> + Add<Y::Outputs>, Y::Inputs: Size<T>, Y::Outputs: Size<T>, <X::Inputs as Add<Y::Inputs>>::Output: Size<T>, <X::Outputs as Add<Y::Outputs>>::Output: Size<T>,

| binary operator: The stack operator stacks inputs and outputs of two nodes running in parallel.

type Output = An<Stack<T, X, Y>>

The resulting type after applying the | operator.

fn bitor(self, y: An<Y>) -> Self::Output

Performs the | operation.

impl<X> BitOr<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the | operator.

fn bitor(self, y: Net32) -> Self::Output

Performs the | operation.

impl<X> BitOr<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the | operator.

fn bitor(self, y: Net64) -> Self::Output

Performs the | operation.

impl<X> BitXor<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the ^ operator.

fn bitxor(self, y: An<X>) -> Self::Output

Performs the ^ operation.

impl<X> BitXor<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the ^ operator.

fn bitxor(self, y: An<X>) -> Self::Output

Performs the ^ operation.

impl<T, X, Y> BitXor<An<Y>> for An<X>

where T: Float, X: AudioNode<Sample = T>, Y: AudioNode<Sample = T, Inputs = X::Inputs>, X::Inputs: Size<T>, X::Outputs: Size<T> + Add<Y::Outputs>, Y::Outputs: Size<T>, <X::Outputs as Add<Y::Outputs>>::Output: Size<T>,

^ binary operator: The branch operator sources two nodes from the same inputs and concatenates their outputs.

type Output = An<Branch<T, X, Y>>

The resulting type after applying the ^ operator.

fn bitxor(self, y: An<Y>) -> Self::Output

Performs the ^ operation.

impl<X> BitXor<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the ^ operator.

fn bitxor(self, y: Net32) -> Self::Output

Performs the ^ operation.

impl<X> BitXor<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the ^ operator.

fn bitxor(self, y: Net64) -> Self::Output

Performs the ^ operation.

impl<X: Clone + AudioNode> Clone for An<X>

fn clone(&self) -> An<X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X: AudioNode> DerefMut for An<X>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<X> Mul<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the * operator.

fn mul(self, y: An<X>) -> Self::Output

Performs the * operation.

impl<X> Mul<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the * operator.

fn mul(self, y: An<X>) -> Self::Output

Performs the * operation.

impl<X> Mul<An<X>> for f32

where X: AudioNode<Sample = f32>, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

constant * X binary operator: Multiplies outputs of X with constant. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f32, X, FrameMulScalar<<X as AudioNode>::Outputs, f32>>>

The resulting type after applying the * operator.

fn mul(self, y: An<X>) -> Self::Output

Performs the * operation.

impl<X> Mul<An<X>> for f64

where X: AudioNode<Sample = f64>, X::Inputs: Size<f64>, X::Outputs: Size<f64>,

constant * X binary operator: Multiplies outputs of X with constant. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f64, X, FrameMulScalar<<X as AudioNode>::Outputs, f64>>>

The resulting type after applying the * operator.

fn mul(self, y: An<X>) -> Self::Output

Performs the * operation.

impl<X, Y> Mul<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Sample = X::Sample, Outputs = X::Outputs>, X::Inputs: Size<X::Sample> + Add<Y::Inputs>, Y::Inputs: Size<Y::Sample>, <X::Inputs as Add<Y::Inputs>>::Output: Size<X::Sample>,

* binary operator: Multiplies outputs of two nodes with disjoint inputs. The nodes must have the same number of outputs.

type Output = An<Binop<<X as AudioNode>::Sample, FrameMul<<X as AudioNode>::Outputs, <X as AudioNode>::Sample>, X, Y>>

The resulting type after applying the * operator.

fn mul(self, y: An<Y>) -> Self::Output

Performs the * operation.

impl<X> Mul<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the * operator.

fn mul(self, y: Net32) -> Self::Output

Performs the * operation.

impl<X> Mul<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the * operator.

fn mul(self, y: Net64) -> Self::Output

Performs the * operation.

impl<X> Mul<f32> for An<X>

where X: AudioNode<Sample = f32>, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

X * constant binary operator: Multiplies outputs of X with constant. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f32, X, FrameMulScalar<<X as AudioNode>::Outputs, f32>>>

The resulting type after applying the * operator.

fn mul(self, y: f32) -> Self::Output

Performs the * operation.

impl<X> Mul<f64> for An<X>

where X: AudioNode<Sample = f64>, X::Inputs: Size<f64>, X::Outputs: Size<f64>,

X * constant binary operator: Multiplies outputs of X with constant. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f64, X, FrameMulScalar<<X as AudioNode>::Outputs, f64>>>

The resulting type after applying the * operator.

fn mul(self, y: f64) -> Self::Output

Performs the * operation.

impl<X> Neg for An<X>

where X: AudioNode, X::Outputs: Size<X::Sample>,

- unary operator: Negates node outputs. Any node can be negated.

type Output = An<Unop<<X as AudioNode>::Sample, X, FrameNeg<<X as AudioNode>::Outputs, <X as AudioNode>::Sample>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<X> Not for An<X>

where X: AudioNode,

! unary operator: The thru operator makes output arity match input arity and passes through missing outputs.

type Output = An<Thru<X>>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<X> Shr<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the >> operator.

fn shr(self, y: An<X>) -> Self::Output

Performs the >> operation.

impl<X> Shr<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the >> operator.

fn shr(self, y: An<X>) -> Self::Output

Performs the >> operation.

impl<T, X, Y> Shr<An<Y>> for An<X>

where T: Float, X: AudioNode<Sample = T>, Y: AudioNode<Sample = T, Inputs = X::Outputs>, X::Inputs: Size<T>, X::Outputs: Size<T>, Y::Outputs: Size<T>,

>> binary operator: The pipe operator pipes outputs of left node to inputs of right node. Number of outputs on the left side and number of inputs on the right side must match.

type Output = An<Pipe<T, X, Y>>

The resulting type after applying the >> operator.

fn shr(self, y: An<Y>) -> Self::Output

Performs the >> operation.

impl<X> Shr<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the >> operator.

fn shr(self, y: Net32) -> Self::Output

Performs the >> operation.

impl<X> Shr<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the >> operator.

fn shr(self, y: Net64) -> Self::Output

Performs the >> operation.

impl<X> Sub<An<X>> for Net32

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the - operator.

fn sub(self, y: An<X>) -> Self::Output

Performs the - operation.

impl<X> Sub<An<X>> for Net64

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the - operator.

fn sub(self, y: An<X>) -> Self::Output

Performs the - operation.

impl<X> Sub<An<X>> for f32

where X: AudioNode<Sample = f32>, X::Inputs: Size<f32> + Add<U0>, X::Outputs: Size<f32>, <X::Inputs as Add<U0>>::Output: Size<f32>,

constant - X binary operator: Negates X and adds constant to its outputs. Broadcasts constant to an arbitrary number of channels.

type Output = An<Binop<f32, FrameSub<<X as AudioNode>::Outputs, f32>, Constant<<X as AudioNode>::Outputs, f32>, X>>

The resulting type after applying the - operator.

fn sub(self, y: An<X>) -> Self::Output

Performs the - operation.

impl<X> Sub<An<X>> for f64

where X: AudioNode<Sample = f64>, X::Inputs: Size<f64> + Add<U0>, X::Outputs: Size<f64>, <X::Inputs as Add<U0>>::Output: Size<f64>,

constant - X binary operator: Negates X and adds constant to its outputs. Broadcasts constant to an arbitrary number of channels.

type Output = An<Binop<f64, FrameSub<<X as AudioNode>::Outputs, f64>, Constant<<X as AudioNode>::Outputs, f64>, X>>

The resulting type after applying the - operator.

fn sub(self, y: An<X>) -> Self::Output

Performs the - operation.

impl<X, Y> Sub<An<Y>> for An<X>

where X: AudioNode, Y: AudioNode<Sample = X::Sample, Outputs = X::Outputs>, X::Inputs: Size<X::Sample> + Add<Y::Inputs>, Y::Inputs: Size<Y::Sample>, <X::Inputs as Add<Y::Inputs>>::Output: Size<X::Sample>,

- binary operator: The difference of outputs of two nodes with disjoint inputs. The nodes must have the same number of outputs.

type Output = An<Binop<<X as AudioNode>::Sample, FrameSub<<X as AudioNode>::Outputs, <X as AudioNode>::Sample>, X, Y>>

The resulting type after applying the - operator.

fn sub(self, y: An<Y>) -> Self::Output

Performs the - operation.

impl<X> Sub<Net32> for An<X>

where X: AudioNode<Sample = f32> + Send + Sync + 'static,

type Output = Net32

The resulting type after applying the - operator.

fn sub(self, y: Net32) -> Self::Output

Performs the - operation.

impl<X> Sub<Net64> for An<X>

where X: AudioNode<Sample = f64> + Send + Sync + 'static,

type Output = Net64

The resulting type after applying the - operator.

fn sub(self, y: Net64) -> Self::Output

Performs the - operation.

impl<X> Sub<f32> for An<X>

where X: AudioNode<Sample = f32>, X::Inputs: Size<f32>, X::Outputs: Size<f32>,

X - constant binary operator: Subtracts constant from outputs of X. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f32, X, FrameAddScalar<<X as AudioNode>::Outputs, f32>>>

The resulting type after applying the - operator.

fn sub(self, y: f32) -> Self::Output

Performs the - operation.

impl<X> Sub<f64> for An<X>

where X: AudioNode<Sample = f64>, X::Inputs: Size<f64>, X::Outputs: Size<f64>,

X - constant binary operator: Subtracts constant from outputs of X. Broadcasts constant to an arbitrary number of channels.

type Output = An<Unop<f64, X, FrameAddScalar<<X as AudioNode>::Outputs, f64>>>

The resulting type after applying the - operator.

fn sub(self, y: f64) -> Self::Output

Performs the - operation.

impl<X: AudioNode> Deref for An<X>

type Target = X

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.