Struct basic_dsp::matrix::MatrixMxN

pub struct MatrixMxN<V, S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T>,  { /* fields omitted */ }

A matrix which can hold 1 to N vectors.

Trait Implementations

impl<V, S, T, N, D> ElementaryOps<MatrixMxN<V, S, T>, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ElementaryOps<V, T, N, D> + GetMetaData<T, N, D>,

fn add(&mut self, summand: &MatrixMxN<V, S, T>) -> Result<(), ErrorReason>

Calculates the sum of self + summand. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn sub(&mut self, summand: &MatrixMxN<V, S, T>) -> Result<(), ErrorReason>

Calculates the difference of self - subtrahend. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn div(&mut self, summand: &MatrixMxN<V, S, T>) -> Result<(), ErrorReason>

Calculates the quotient of self / summand. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn mul(&mut self, summand: &MatrixMxN<V, S, T>) -> Result<(), ErrorReason>

Calculates the product of self * factor. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

impl<V, S, T, N, D> ElementaryOps<V, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ElementaryOps<V, T, N, D> + GetMetaData<T, N, D>,

fn add(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the sum of self + summand. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn sub(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the difference of self - subtrahend. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn div(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the quotient of self / summand. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn mul(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the product of self * factor. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

impl<V, S, T> ComplexToRealTransformsOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ComplexToRealTransformsOps<T>,     <V as ToRealResult>::RealResult: Vector<T>,

fn magnitude(self) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult

Gets the absolute value, magnitude or norm of all vector elements. # Example

fn magnitude_squared(self) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult

Gets the square root of the absolute value of all vector elements. # Example

fn to_real(self) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult

Gets all real elements. # Example

fn to_imag(self) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult

Gets all imag elements. # Example

fn phase(self) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult

Gets the phase of all elements in [rad]. # Example

impl<V, S, T, N, D> GetMetaData<T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + GetMetaData<T, N, D>,

fn get_meta_data(&self) -> TypeMetaData<T, N, D>

Gets a copy of the vector meta data. This can be used to create new types with the same meta data.

impl<S, V, T> PreciseStatisticsOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + PreciseStatisticsOps<Statistics<T>, Result = Statistics<T>>,

type Result = Vec<Statistics<T>>

fn statistics_prec(&self) -> Vec<Statistics<T>>

Calculates the statistics of the data contained in the vector using a more precise but slower algorithm.

impl<V, S, T, N, D, O> ComplexToRealSetterOps<O, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     O: Matrix<V, T> + GetMetaData<T, N, D>,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ComplexToRealSetterOps<V, T, N, D> + GetMetaData<T, N, D>,

fn set_real_imag(&mut self, real: &O, imag: &O) -> Result<(), ErrorReason>

Overrides the self vectors data with the real and imaginary data in the given vectors. real and imag must have the same size.

fn set_mag_phase(&mut self, mag: &O, phase: &O) -> Result<(), ErrorReason>

Overrides the self vectors data with the magnitude and phase data in the given vectors. Note that self vector will immediately convert the data into a real and imaginary representation of the complex numbers which is its default format. mag and phase must have the same size.

impl<S, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for MatrixMxN<DspVec<S, T, N, D>, S, T> where     D: Domain,     N: NumberSpace,     S: ToSliceMut<T>,     T: RealNumber,     DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,

fn convolve_signal<B>(     &mut self,     buffer: &mut B,     impulse_response: &DspVec<S, T, N, D> ) -> Result<(), ErrorReason> where     B: Buffer<'b, S, T>,

Convolves self with the convolution function impulse_response. For performance it's recommended to use multiply both vectors in frequency domain instead of this operation.

impl<'a, S, T, N, D> ConvolutionOps<Vec<&'a Vec<&'a DspVec<S, T, N, D>>>, S, T, N, D> for MatrixMxN<DspVec<S, T, N, D>, S, T> where     D: Domain,     N: NumberSpace,     S: ToSliceMut<T>,     T: RealNumber,

fn convolve_signal<B>(     &mut self,     buffer: &mut B,     impulse_response: &Vec<&Vec<&DspVec<S, T, N, D>>> ) -> Result<(), ErrorReason> where     B: Buffer<'b, S, T>,

Convolves self with the convolution function impulse_response. For performance it's recommended to use multiply both vectors in frequency domain instead of this operation.

impl<V, S, T> ToTimeResult for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ToTimeResult,     <V as ToTimeResult>::TimeResult: Vector<T>,

type TimeResult = MatrixMxN<<V as ToTimeResult>::TimeResult, S, T>

Specifies what the the result is if a type is transformed to time domain.

impl<V, S, T> SymmetricTimeToFrequencyDomainOperations<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + SymmetricTimeToFrequencyDomainOperations<S, T>,     <V as ToFreqResult>::FreqResult: Vector<T>,

fn plain_sfft<B>(     self,     buffer: &mut B ) -> Result<<MatrixMxN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult)> where     B: Buffer<'b, S, T>,

Performs a Symmetric Fast Fourier Transformation under the assumption that self is symmetric around the center. This assumption isn't verified and no error is raised if the vector isn't symmetric.

fn sfft<B>(     self,     buffer: &mut B ) -> Result<<MatrixMxN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult)> where     B: Buffer<'b, S, T>,

Performs a Symmetric Fast Fourier Transformation under the assumption that self is symmetric around the center. This assumption isn't verified and no error is raised if the vector isn't symmetric. # Failures TransRes may report the following ErrorReason members:

fn windowed_sfft<B>(     self,     buffer: &mut B,     window: &dyn WindowFunction<T> ) -> Result<<MatrixMxN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult)> where     B: Buffer<'b, S, T>,

Performs a Symmetric Fast Fourier Transformation under the assumption that self is symmetric around the center. This assumption isn't verified and no error is raised if the vector isn't symmetric. # Failures TransRes may report the following ErrorReason members:

impl<V, S, T> RealOps for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + RealOps,

fn abs(&mut self)

Gets the absolute value of all vector elements. # Example

impl<V, S, T> FrequencyDomainOperations<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + FrequencyDomainOperations<S, T>,

fn mirror<B>(&mut self, buffer: &mut B) where     B: Buffer<'b, S, T>,

This function mirrors the spectrum vector to transform a symmetric spectrum into a full spectrum with the DC element at index 0 (no FFT shift/swap halves).

fn fft_shift(&mut self)

Swaps vector halves after a Fourier Transformation.

fn ifft_shift(&mut self)

Swaps vector halves before an Inverse Fourier Transformation.

impl<V, S, T> RealInterpolationOps<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + RealInterpolationOps<S, T>,

fn interpolate_hermite<B>(     &mut self,     buffer: &mut B,     interpolation_factor: T,     delay: T ) where     B: Buffer<'b, S, T>,

Piecewise cubic hermite interpolation between samples.

fn interpolate_lin<B>(     &mut self,     buffer: &mut B,     interpolation_factor: T,     delay: T ) where     B: Buffer<'b, S, T>,

Linear interpolation between samples.

impl<V, S, T> ToRealTimeResult for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ToRealTimeResult,     <V as ToRealTimeResult>::RealTimeResult: Vector<T>,

type RealTimeResult = MatrixMxN<<V as ToRealTimeResult>::RealTimeResult, S, T>

impl<S, V, T> StatisticsOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + StatisticsOps<Statistics<T>, Result = Statistics<T>>,

type Result = Vec<Statistics<T>>

fn statistics(&self) -> Vec<Statistics<T>>

Calculates the statistics of the data.

impl<S, V, T, R> MapAggregateOps<T, R> for MatrixMxN<V, S, T> where     R: Send,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>,

type Output = Result<Vec<R>, ErrorReason>

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> Result<Vec<R>, ErrorReason> where     A: Sync + Copy + Send,     FAggr: Fn(R, R) -> R + 'a + Sync + Send,     FMap: Fn(T, usize, A) -> R + 'a + Sync,     R: Send,

Transforms all vector elements using the function map and then aggregates all the results with aggregate. aggregate must be a commutativity and associativity; that's because there is no guarantee that the numbers will be aggregated in any deterministic order.

impl<V, S, T, N, D, O> ComplexToRealGetterOps<O, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     O: Matrix<V, T> + GetMetaData<T, N, D>,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ComplexToRealGetterOps<V, T, N, D> + GetMetaData<T, N, D>,

fn get_real(&self, destination: &mut O)

Copies all real elements into the given vector. # Example

fn get_imag(&self, destination: &mut O)

Copies all imag elements into the given vector. # Example

fn get_magnitude(&self, destination: &mut O)

Copies the absolute value or magnitude of all vector elements into the given target vector. # Example

fn get_magnitude_squared(&self, destination: &mut O)

Copies the absolute value squared or magnitude squared of all vector elements into the given target vector. # Example

fn get_phase(&self, destination: &mut O)

Copies the phase of all elements in [rad] into the given vector. # Example

fn get_real_imag(&self, real: &mut O, imag: &mut O)

Gets the real and imaginary parts and stores them in the given vectors. See also get_phase and get_complex_abs for further information.

fn get_mag_phase(&self, mag: &mut O, phase: &mut O)

Gets the magnitude and phase and stores them in the given vectors. See also get_real and get_imag for further information.

impl<S, T, N, D, O, V> CrossCorrelationOps<O, S, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     O: Matrix<V, T> + GetMetaData<T, N, D>,     S: ToSliceMut<T>,     T: RealNumber,     V: CrossCorrelationOps<V, S, T, N, D> + GetMetaData<T, N, D> + Vector<T>,

fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> Result<(), ErrorReason> where     B: Buffer<'b, S, T>,

Calculates the correlation between self and other. other needs to be a time vector which went through one of the prepare functions prepare_argument or prepare_argument_padded. See also the trait description for more details.

impl<V, S, T> CrossCorrelationArgumentOps<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + CrossCorrelationArgumentOps<S, T>,     <V as ToFreqResult>::FreqResult: Vector<T>,

fn prepare_argument<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult where     B: Buffer<'b, S, T>,

Prepares an argument to be used for convolution. Preparing an argument includes two steps:

fn prepare_argument_padded<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult where     B: Buffer<'b, S, T>,

Prepares an argument to be used for convolution. The argument is zero padded to length of 2 * self.points() - 1 and then the same operations are performed as described for prepare_argument.

impl<V, S, T> ComplexToRealTransformsOpsBuffered<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + ComplexToRealTransformsOpsBuffered<S, T>,     <V as ToRealResult>::RealResult: Vector<T>,

fn magnitude_b<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult where     B: Buffer<'b, S, T>,

Gets the absolute value, magnitude or norm of all vector elements. # Example

fn magnitude_squared_b<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult where     B: Buffer<'b, S, T>,

Gets the square root of the absolute value of all vector elements. # Example

fn to_real_b<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult where     B: Buffer<'b, S, T>,

Gets all real elements. # Example

fn to_imag_b<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult where     B: Buffer<'b, S, T>,

Gets all imag elements. # Example

fn phase_b<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToRealResult>::RealResult where     B: Buffer<'b, S, T>,

Gets the phase of all elements in [rad]. # Example

impl<V, S, T> ReorganizeDataOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ReorganizeDataOps<T>,

fn reverse(&mut self)

Reverses the data inside the vector.

fn swap_halves(&mut self)

This function swaps both halves of the vector. This operation is also called FFT shift Use it after a plain_fft to get a spectrum which is centered at 0 Hz.

impl<S, V, T> ApproximatedOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ApproximatedOps<T>,

fn ln_approx(&mut self)

Computes the principal value approximation of natural logarithm of every element in the vector.

fn exp_approx(&mut self)

Calculates the natural exponential approximation for every vector element.

fn sin_approx(&mut self)

Calculates the sine approximation of each element in radians.

fn cos_approx(&mut self)

Calculates the cosine approximation of each element in radians

fn log_approx(&mut self, base: T)

Calculates the approximated logarithm to the given base for every vector element.

fn expf_approx(&mut self, base: T)

Calculates the approximated exponential to the given base for every vector element.

fn powf_approx(&mut self, exponent: T)

Raises every vector element to approximately a floating point power.

impl<V, S, T> ToFreqResult for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ToFreqResult,     <V as ToFreqResult>::FreqResult: Vector<T>,

type FreqResult = MatrixMxN<<V as ToFreqResult>::FreqResult, S, T>

impl<V, S, T> ModuloOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ModuloOps<T>,

fn wrap(&mut self, divisor: T)

Each value in the vector is dividable by the divisor and the remainder is stored in the resulting vector. This the same a modulo operation or to phase wrapping.

fn unwrap(&mut self, divisor: T)

This function corrects the jumps in the given vector which occur due to wrap or modulo operations. This will undo a wrap operation only if the deltas are smaller than half the divisor.

impl<S, V, T, O> PreciseSumOps<Vec<O>> for MatrixMxN<V, S, T> where     O: RealNumber,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + PreciseSumOps<O>,

fn sum_prec(&self) -> Vec<O>

Calculates the sum of the data contained in the vector using a more precise but slower algorithm. # Example

fn sum_sq_prec(&self) -> Vec<O>

Calculates the sum of the squared data contained in the vector using a more precise but slower algorithm. # Example

impl<V, S, T> TimeDomainOperations<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + TimeDomainOperations<S, T>,

fn apply_window(&mut self, window: &dyn WindowFunction<T>)

Applies a window to the data vector.

fn unapply_window(&mut self, window: &dyn WindowFunction<T>)

Removes a window from the data vector.

impl<V, S, T> ResizeOps for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T>,

fn resize(&mut self, len: usize) -> Result<(), ErrorReason>

Changes self.len(). If self.is_complex() is true then len must be an even number. len > self.alloc_len() is only possible if the underlying storage supports resizing.

impl<V, S, T> ToRealResult for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ToRealResult,     <V as ToRealResult>::RealResult: Vector<T>,

type RealResult = MatrixMxN<<V as ToRealResult>::RealResult, S, T>

impl<V, S, T> MetaData for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T>,

fn domain(&self) -> DataDomain

The domain in which the data vector resides. Basically specifies the x-axis and the type of operations which are valid on this vector.

fn is_complex(&self) -> bool

Indicates whether the vector contains complex data. This also specifies the type of operations which are valid on this vector.

impl<S, V, T> PreciseStatisticsSplitOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + PreciseStatisticsSplitOps<Statistics<T>, Result = ArrayVec<[Statistics<T>; 16]>>,

type Result = Vec<ArrayVec<[Statistics<T>; 16]>>

fn statistics_split_prec(     &self,     len: usize ) -> Result<Vec<ArrayVec<[Statistics<T>; 16]>>, ErrorReason>

Calculates the statistics of the data contained in the vector as if the vector would have been split into len pieces using a more precise but slower algorithm. self.len should be dividable by len without a remainder, but this isn't enforced by the implementation. For implementation reasons len <= 16 must be true.

impl<V, S, T> TimeToFrequencyDomainOperations<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + TimeToFrequencyDomainOperations<S, T>,     <V as ToFreqResult>::FreqResult: Vector<T>,

fn plain_fft<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult where     B: Buffer<'b, S, T>,

Performs a Fast Fourier Transformation transforming a time domain vector into a frequency domain vector.

fn fft<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult where     B: Buffer<'b, S, T>,

Performs a Fast Fourier Transformation transforming a time domain vector into a frequency domain vector. # Example

fn windowed_fft<B>(     self,     buffer: &mut B,     window: &dyn WindowFunction<T> ) -> <MatrixMxN<V, S, T> as ToFreqResult>::FreqResult where     B: Buffer<'b, S, T>,

Applies a FFT window and performs a Fast Fourier Transformation transforming a time domain vector into a frequency domain vector.

impl<S, V, T, N, D> PreciseDotProductOps<V, T, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + PreciseDotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,

type Output = Result<Vec<T>, ErrorReason>

fn dot_product_prec(&self, factor: &V) -> Result<Vec<T>, ErrorReason>

Calculates the dot product of self and factor using a more precise but slower algorithm. Self and factor remain unchanged.

impl<S, V, T, N, D> PreciseDotProductOps<MatrixMxN<V, S, T>, T, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + PreciseDotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,

type Output = Result<Vec<T>, ErrorReason>

fn dot_product_prec(     &self,     factor: &MatrixMxN<V, S, T> ) -> Result<Vec<T>, ErrorReason>

Calculates the dot product of self and factor using a more precise but slower algorithm. Self and factor remain unchanged.

impl<V, S, T> InterpolationOps<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + InterpolationOps<S, T>,

fn interpolatef<B>(     &mut self,     buffer: &mut B,     function: &dyn RealImpulseResponse<T>,     interpolation_factor: T,     delay: T,     conv_len: usize ) where     B: Buffer<'b, S, T>,

Interpolates self with the convolution function function by the real value interpolation_factor. InterpolationOps is done in time domain and the argument conv_len can be used to balance accuracy and computational performance. A delay can be used to delay or phase shift the vector. The delay considers self.delta().

fn interpolatei<B>(     &mut self,     buffer: &mut B,     function: &dyn RealFrequencyResponse<T>,     interpolation_factor: u32 ) -> Result<(), ErrorReason> where     B: Buffer<'b, S, T>,

Interpolates self with the convolution function function by the integer value interpolation_factor. InterpolationOps is done in in frequency domain.

fn interpolate<B>(     &mut self,     buffer: &mut B,     function: Option<&dyn RealFrequencyResponse<T>>,     dest_points: usize,     delay: T ) -> Result<(), ErrorReason> where     B: Buffer<'b, S, T>,

Interpolates the signal in frequency domain by padding it with zeros.

fn interpft<B>(&mut self, buffer: &mut B, dest_points: usize) where     B: Buffer<'b, S, T>,

Interpolates the signal in frequency domain by padding it with zeros. This function preserves the shape of the signal in frequency domain.

fn decimatei(&mut self, decimation_factor: u32, delay: u32)

Decimates or downsamples self. decimatei is the inverse function to interpolatei.

impl<V, S, T> RealToComplexTransformsOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + RealToComplexTransformsOps<T>,     <V as ToComplexResult>::ComplexResult: Vector<T>,

fn to_complex(     self ) -> Result<<MatrixMxN<V, S, T> as ToComplexResult>::ComplexResult, (ErrorReason, <MatrixMxN<V, S, T> as ToComplexResult>::ComplexResult)>

Converts the real vector into a complex vector.

impl<V, S, T> SymmetricFrequencyToTimeDomainOperations<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + SymmetricFrequencyToTimeDomainOperations<S, T>,     <V as ToRealTimeResult>::RealTimeResult: Vector<T>,

fn plain_sifft<B>(     self,     buffer: &mut B ) -> Result<<MatrixMxN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <MatrixMxN<V, S, T> as ToRealTimeResult>::RealTimeResult)> where     B: Buffer<'b, S, T>,

Performs a Symmetric Inverse Fast Fourier Transformation under the assumption that self contains half of a symmetric spectrum starting from 0 Hz. This assumption isn't verified and no error is raised if the spectrum isn't symmetric. The reason for this is that there is no robust verification possible.

fn sifft<B>(     self,     buffer: &mut B ) -> Result<<MatrixMxN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <MatrixMxN<V, S, T> as ToRealTimeResult>::RealTimeResult)> where     B: Buffer<'b, S, T>,

Performs a Symmetric Inverse Fast Fourier Transformation under the assumption that self contains half of a symmetric spectrum starting from 0 Hz. This assumption isn't verified and no error is raised if the spectrum isn't symmetric. The reason for this is that there is no robust verification possible.

fn windowed_sifft<B>(     self,     buffer: &mut B,     window: &dyn WindowFunction<T> ) -> Result<<MatrixMxN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <MatrixMxN<V, S, T> as ToRealTimeResult>::RealTimeResult)> where     B: Buffer<'b, S, T>,

Performs a Symmetric Inverse Fast Fourier Transformation (SIFFT) and removes the FFT window. The SIFFT is performed under the assumption that self contains half of a symmetric spectrum starting from 0 Hz. This assumption isn't verified and no error is raised if the spectrum isn't symmetric. The reason for this is that there is no robust verification possible.

impl<S, V, T> DiffSumOps for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + DiffSumOps,

fn diff(&mut self)

Calculates the delta of each elements to its previous element. This will decrease the vector length by one point.

fn diff_with_start(&mut self)

Calculates the delta of each elements to its previous element. The first element will remain unchanged.

fn cum_sum(&mut self)

Calculates the cumulative sum of all elements. This operation undoes the diff_with_startoperation.

impl<S, V, T, N, D> DotProductOps<MatrixMxN<V, S, T>, T, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + DotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,

type Output = Result<Vec<T>, ErrorReason>

fn dot_product(     &self,     factor: &MatrixMxN<V, S, T> ) -> Result<Vec<T>, ErrorReason>

Calculates the dot product of self and factor. Self and factor remain unchanged.

impl<S, V, T, N, D> DotProductOps<V, T, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + DotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,

type Output = Result<Vec<T>, ErrorReason>

fn dot_product(&self, factor: &V) -> Result<Vec<T>, ErrorReason>

Calculates the dot product of self and factor. Self and factor remain unchanged.

impl<V, S, T> ComplexOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ComplexOps<T>,

fn multiply_complex_exponential(&mut self, a: T, b: T)

Multiplies each vector element with exp(j*(a*idx*self.delta() + b)) where a and b are arguments and idx is the index of the data points in the vector ranging from 0 to self.points() - 1. j is the imaginary number and exp the exponential function.

fn conj(&mut self)

Calculates the complex conjugate of the vector. # Example

impl<V, S, T> OffsetOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + OffsetOps<T>,

fn offset(&mut self, offset: T)

Adds a scalar to each vector element.

impl<V, S, T> OffsetOps<Complex<T>> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + OffsetOps<Complex<T>>,

fn offset(&mut self, offset: Complex<T>)

Adds a scalar to each vector element.

impl<V, O, S, T> RededicateForceOps<MatrixMxN<O, S, T>> for MatrixMxN<V, S, T> where     O: Vector<T>,     S: ToSlice<T>,     T: RealNumber + RealNumber,     V: RededicateForceOps<O> + Vector<T>,

fn rededicate_from_force(origin: MatrixMxN<O, S, T>) -> MatrixMxN<V, S, T>

Make Other a Self without performing any checks.

fn rededicate_with_runtime_data(     origin: MatrixMxN<O, S, T>,     is_complex: bool,     domain: DataDomain ) -> MatrixMxN<V, S, T>

Make Other a Self without performing any checks.

impl<S, V, T> SumOps<Vec<T>> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + SumOps<T>,

fn sum(&self) -> Vec<T>

Calculates the sum of the data contained in the vector. # Example

fn sum_sq(&self) -> Vec<T>

Calculates the sum of the squared data contained in the vector. # Example

impl<V, S, T, N, D> ElementaryWrapAroundOps<MatrixMxN<V, S, T>, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ElementaryWrapAroundOps<V, T, N, D> + GetMetaData<T, N, D>,

fn add_smaller(     &mut self,     summand: &MatrixMxN<V, S, T> ) -> Result<(), ErrorReason>

Calculates the sum of self + summand. summand may be smaller than self as long as self.len() % summand.len() == 0. THe result is the same as it would be if you would repeat summand until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn sub_smaller(     &mut self,     summand: &MatrixMxN<V, S, T> ) -> Result<(), ErrorReason>

Calculates the sum of self - subtrahend. subtrahend may be smaller than self as long as self.len() % subtrahend.len() == 0. THe result is the same as it would be if you would repeat subtrahend until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn div_smaller(     &mut self,     summand: &MatrixMxN<V, S, T> ) -> Result<(), ErrorReason>

Calculates the sum of self - divisor. divisor may be smaller than self as long as self.len() % divisor.len() == 0. THe result is the same as it would be if you would repeat divisor until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn mul_smaller(     &mut self,     summand: &MatrixMxN<V, S, T> ) -> Result<(), ErrorReason>

Calculates the sum of self - factor. factor may be smaller than self as long as self.len() % factor.len() == 0. THe result is the same as it would be if you would repeat factor until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

impl<V, S, T, N, D> ElementaryWrapAroundOps<V, T, N, D> for MatrixMxN<V, S, T> where     D: Domain,     N: NumberSpace,     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ElementaryWrapAroundOps<V, T, N, D> + GetMetaData<T, N, D>,

fn add_smaller(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the sum of self + summand. summand may be smaller than self as long as self.len() % summand.len() == 0. THe result is the same as it would be if you would repeat summand until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn sub_smaller(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the sum of self - subtrahend. subtrahend may be smaller than self as long as self.len() % subtrahend.len() == 0. THe result is the same as it would be if you would repeat subtrahend until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn div_smaller(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the sum of self - divisor. divisor may be smaller than self as long as self.len() % divisor.len() == 0. THe result is the same as it would be if you would repeat divisor until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

fn mul_smaller(&mut self, summand: &V) -> Result<(), ErrorReason>

Calculates the sum of self - factor. factor may be smaller than self as long as self.len() % factor.len() == 0. THe result is the same as it would be if you would repeat factor until it has the same length as self. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

impl<S, V, T> StatisticsSplitOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + StatisticsSplitOps<Statistics<T>, Result = ArrayVec<[Statistics<T>; 16]>>,

type Result = Vec<ArrayVec<[Statistics<T>; 16]>>

fn statistics_split(     &self,     len: usize ) -> Result<Vec<ArrayVec<[Statistics<T>; 16]>>, ErrorReason>

Calculates the statistics of the data contained in the vector as if the vector would have been split into len pieces. self.len should be dividable by len without a remainder, but this isn't enforced by the implementation. For implementation reasons len <= 16 must be true.

impl<'a, V, S, T> Convolution<'a, S, T, &'a (dyn ComplexImpulseResponse<T> + 'a)> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + Convolution<'a, S, T, &'a (dyn ComplexImpulseResponse<T> + 'a)>,

fn convolve<B>(     &mut self,     buffer: &mut B,     impulse_response: &'a (dyn ComplexImpulseResponse<T> + 'a),     ratio: T,     len: usize ) where     B: Buffer<'b, S, T>,

Convolves self with the convolution function impulse_response. For performance consider to to use FrequencyMultiplication instead of this operation depending on len.

impl<'a, V, S, T> Convolution<'a, S, T, &'a (dyn RealImpulseResponse<T> + 'a)> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + Convolution<'a, S, T, &'a (dyn RealImpulseResponse<T> + 'a)>,

fn convolve<B>(     &mut self,     buffer: &mut B,     impulse_response: &'a (dyn RealImpulseResponse<T> + 'a),     ratio: T,     len: usize ) where     B: Buffer<'b, S, T>,

Convolves self with the convolution function impulse_response. For performance consider to to use FrequencyMultiplication instead of this operation depending on len.

impl<V, S, T> ToComplexResult for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ToComplexResult,     <V as ToComplexResult>::ComplexResult: Vector<T>,

type ComplexResult = MatrixMxN<<V as ToComplexResult>::ComplexResult, S, T>

impl<S, V, T> TrigOps for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + TrigOps,

fn sin(&mut self)

Calculates the sine of each element in radians.

fn cos(&mut self)

Calculates the cosine of each element in radians.

fn tan(&mut self)

Calculates the tangent of each element in radians.

fn asin(&mut self)

Calculates the principal value of the inverse sine of each element in radians.

fn acos(&mut self)

Calculates the principal value of the inverse cosine of each element in radians.

fn atan(&mut self)

Calculates the principal value of the inverse tangent of each element in radians.

fn sinh(&mut self)

Calculates the hyperbolic sine each element in radians.

fn cosh(&mut self)

Calculates the hyperbolic cosine each element in radians.

fn tanh(&mut self)

Calculates the hyperbolic tangent each element in radians.

fn asinh(&mut self)

Calculates the principal value of the inverse hyperbolic sine of each element in radians.

fn acosh(&mut self)

Calculates the principal value of the inverse hyperbolic cosine of each element in radians.

fn atanh(&mut self)

Calculates the principal value of the inverse hyperbolic tangent of each element in radians.

impl<V, S, T> RealToComplexTransformsOpsBuffered<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + RealToComplexTransformsOpsBuffered<S, T>,     <V as ToComplexResult>::ComplexResult: Vector<T>,

fn to_complex_b<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToComplexResult>::ComplexResult where     B: Buffer<'b, S, T>,

Converts the real vector into a complex vector. The buffer allows this operation to succeed even if the storage type doesn't allow resizing.

impl<S, V, T> PowerOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + PowerOps<T>,

fn sqrt(&mut self)

Gets the square root of all vector elements.

fn square(&mut self)

Squares all vector elements.

fn root(&mut self, degree: T)

Calculates the n-th root of every vector element.

fn powf(&mut self, exponent: T)

Raises every vector element to a floating point power.

fn ln(&mut self)

Computes the principal value of natural logarithm of every element in the vector.

fn exp(&mut self)

Calculates the natural exponential for every vector element.

fn log(&mut self, base: T)

Calculates the logarithm to the given base for every vector element.

fn expf(&mut self, base: T)

Calculates the exponential to the given base for every vector element.

impl<V, S, T> ScaleOps<Complex<T>> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ScaleOps<Complex<T>>,

fn scale(&mut self, factor: Complex<T>)

Multiplies the vector element with a scalar.

impl<V, S, T> ScaleOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + ScaleOps<T>,

fn scale(&mut self, factor: T)

Multiplies the vector element with a scalar.

impl<V, S, T> Matrix<V, T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T>,

fn delta(&self) -> T

The x-axis delta. If domain is time domain then delta is in [s], in frequency domain delta is in [Hz].

fn set_delta(&mut self, delta: T)

Sets the x-axis delta. If domain is time domain then delta is in [s], in frequency domain delta is in [Hz].

fn row_len(&self) -> usize

The number of valid elements in each row of the matrix. This can be changed with the Resize trait.

fn row_points(&self) -> usize

The number of valid points in a row. If the matrix is complex then every valid point consists of two floating point numbers, while for real vectors every point only consists of one floating point number.

fn col_len(&self) -> usize

The number of columns in the matrix.

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

fn rows(&self) -> &[V]

Gets the rows as vectors.

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

fn rows_mut(&mut self) -> &mut [V]

Gets the rows as mutable vectors.

impl<V, S, T> FrequencyToTimeDomainOperations<S, T> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + FrequencyToTimeDomainOperations<S, T>,     <V as ToTimeResult>::TimeResult: Vector<T>,

fn plain_ifft<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToTimeResult>::TimeResult where     B: Buffer<'b, S, T>,

Performs an Inverse Fast Fourier Transformation transforming a frequency domain vector into a time domain vector.

fn ifft<B>(     self,     buffer: &mut B ) -> <MatrixMxN<V, S, T> as ToTimeResult>::TimeResult where     B: Buffer<'b, S, T>,

Performs an Inverse Fast Fourier Transformation transforming a frequency domain vector into a time domain vector. # Example

fn windowed_ifft<B>(     self,     buffer: &mut B,     window: &dyn WindowFunction<T> ) -> <MatrixMxN<V, S, T> as ToTimeResult>::TimeResult where     B: Buffer<'b, S, T>,

Performs an Inverse Fast Fourier Transformation transforming a frequency domain vector into a time domain vector and removes the FFT window.

impl<'a, V, S, T> FrequencyMultiplication<'a, S, T, &'a (dyn ComplexFrequencyResponse<T> + 'a)> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + FrequencyMultiplication<'a, S, T, &'a (dyn ComplexFrequencyResponse<T> + 'a)>,

fn multiply_frequency_response(     &mut self,     frequency_response: &'a (dyn ComplexFrequencyResponse<T> + 'a),     ratio: T )

Multiplies self with the frequency response function frequency_response.

impl<'a, V, S, T> FrequencyMultiplication<'a, S, T, &'a (dyn RealFrequencyResponse<T> + 'a)> for MatrixMxN<V, S, T> where     S: ToSliceMut<T>,     T: RealNumber,     V: Vector<T> + FrequencyMultiplication<'a, S, T, &'a (dyn RealFrequencyResponse<T> + 'a)>,

fn multiply_frequency_response(     &mut self,     frequency_response: &'a (dyn RealFrequencyResponse<T> + 'a),     ratio: T )

Multiplies self with the frequency response function frequency_response.

impl<V, S, T> FromMatrix<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T>,

type Output = Vec<V>

Type of the underlying storage of a matrix.

fn get(self) -> (<MatrixMxN<V, S, T> as FromMatrix<T>>::Output, usize)

Gets the underlying matrix and the number of elements which contain valid.

impl<S, V, T> MapInplaceOps<T> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + MapInplaceOps<T>,

fn map_inplace<'a, A, F>(&mut self, argument: A, map: &F) where     A: Sync + Copy + Send,     F: Fn(T, usize, A) -> T + 'a + Sync,

Transforms all vector elements using the function map.

impl<S, V, T> MapInplaceOps<Complex<T>> for MatrixMxN<V, S, T> where     S: ToSlice<T>,     T: RealNumber,     V: Vector<T> + MapInplaceOps<Complex<T>>,

fn map_inplace<'a, A, F>(&mut self, argument: A, map: &F) where     A: Sync + Copy + Send,     F: Fn(Complex<T>, usize, A) -> Complex<T> + 'a + Sync,

Transforms all vector elements using the function map.