Struct basic_dsp::matrix::Matrix4xN

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

A matrix which can hold exactly 4 vectors.

Trait Implementations

impl<S, V, T> ApproximatedOps<T> for Matrix4xN<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> ComplexOps<T> for Matrix4xN<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, N, D, O> ComplexToRealGetterOps<O, T, N, D> for Matrix4xN<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<V, S, T, N, D, O> ComplexToRealSetterOps<O, T, N, D> for Matrix4xN<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<V, S, T> ComplexToRealTransformsOps<T> for Matrix4xN<V, S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T> + ComplexToRealTransformsOps<T>,
    <V as ToRealResult>::RealResult: Vector<T>, 

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

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

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

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

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

Gets all real elements. # Example

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

Gets all imag elements. # Example

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

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

impl<V, S, T> ComplexToRealTransformsOpsBuffered<S, T> for Matrix4xN<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
) -> <Matrix4xN<V, S, T> as ToRealResult>::RealResult where
    B: for<'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
) -> <Matrix4xN<V, S, T> as ToRealResult>::RealResult where
    B: for<'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
) -> <Matrix4xN<V, S, T> as ToRealResult>::RealResult where
    B: for<'b> Buffer<'b, S, T>, 

Gets all real elements. # Example

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

Gets all imag elements. # Example

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

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

impl<'a, V, S, T> Convolution<'a, S, T, &'a (dyn ComplexImpulseResponse<T> + 'a)> for Matrix4xN<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: for<'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 Matrix4xN<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: for<'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, S, T, N, D> ConvolutionOps<[[&'a DspVec<S, T, N, D>; 4]; 4], S, T, N, D> for Matrix4xN<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: &[[&'a DspVec<S, T, N, D>; 4]; 4]
) -> Result<(), ErrorReason> where
    B: for<'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<S, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix4xN<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: for<'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> CrossCorrelationArgumentOps<S, T> for Matrix4xN<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
) -> <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult where
    B: for<'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
) -> <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult where
    B: for<'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<S, T, N, D, O, V> CrossCorrelationOps<O, S, T, N, D> for Matrix4xN<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: for<'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<S, V, T> DiffSumOps for Matrix4xN<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<Matrix4xN<V, S, T>, T, T, N, D> for Matrix4xN<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: &Matrix4xN<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 Matrix4xN<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<[T; 4], ErrorReason>

fn dot_product(&self, factor: &V) -> Result<[T; 4], ErrorReason>

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

impl<V, S, T, N, D> ElementaryOps<Matrix4xN<V, S, T>, T, N, D> for Matrix4xN<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: &Matrix4xN<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: &Matrix4xN<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: &Matrix4xN<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: &Matrix4xN<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 Matrix4xN<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, N, D> ElementaryWrapAroundOps<Matrix4xN<V, S, T>, T, N, D> for Matrix4xN<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: &Matrix4xN<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: &Matrix4xN<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: &Matrix4xN<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: &Matrix4xN<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 Matrix4xN<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<V, S, T> FrequencyDomainOperations<S, T> for Matrix4xN<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: for<'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<'a, V, S, T> FrequencyMultiplication<'a, S, T, &'a (dyn ComplexFrequencyResponse<T> + 'a)> for Matrix4xN<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 Matrix4xN<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> FrequencyToTimeDomainOperations<S, T> for Matrix4xN<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
) -> <Matrix4xN<V, S, T> as ToTimeResult>::TimeResult where
    B: for<'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
) -> <Matrix4xN<V, S, T> as ToTimeResult>::TimeResult where
    B: for<'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>
) -> <Matrix4xN<V, S, T> as ToTimeResult>::TimeResult where
    B: for<'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<V, S, T> FromMatrix<T> for Matrix4xN<V, S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T>, 

type Output = [V; 4]

Type of the underlying storage of a matrix.

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

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

impl<V, S, T, N, D> GetMetaData<T, N, D> for Matrix4xN<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<V, S, T> InterpolationOps<S, T> for Matrix4xN<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: for<'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: for<'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: for<'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: for<'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<S, V, T, R> MapAggregateOps<T, R> for Matrix4xN<V, S, T> where
    R: Send,
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>, 

type Output = Result<[R; 4], ErrorReason>

fn map_aggregate<'a, A, FMap, FAggr>(
    &self,
    argument: A,
    map: &FMap,
    aggregate: &FAggr
) -> Result<[R; 4], 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<S, V, T> MapInplaceOps<Complex<T>> for Matrix4xN<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.

impl<S, V, T> MapInplaceOps<T> for Matrix4xN<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<V, S, T> Matrix<V, T> for Matrix4xN<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.

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

Gets the rows as vectors.

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

Gets the rows as mutable vectors.

impl<V, S, T> MetaData for Matrix4xN<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<V, S, T> ModuloOps<T> for Matrix4xN<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<V, S, T> OffsetOps<Complex<T>> for Matrix4xN<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, S, T> OffsetOps<T> for Matrix4xN<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<S, V, T> PowerOps<T> for Matrix4xN<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<S, V, T, N, D> PreciseDotProductOps<Matrix4xN<V, S, T>, T, T, N, D> for Matrix4xN<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: &Matrix4xN<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<S, V, T, N, D> PreciseDotProductOps<V, T, T, N, D> for Matrix4xN<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<[T; 4], ErrorReason>

fn dot_product_prec(&self, factor: &V) -> Result<[T; 4], 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> PreciseStatisticsOps<T> for Matrix4xN<V, S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T> + PreciseStatisticsOps<Statistics<T>, Result = Statistics<T>>, 

type Result = [Statistics<T>; 4]

fn statistics_prec(
    &self
) -> <Matrix4xN<V, S, T> as PreciseStatisticsOps<T>>::Result

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

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

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

fn statistics_split_prec(
    &self,
    len: usize
) -> Result<<Matrix4xN<V, S, T> as PreciseStatisticsSplitOps<T>>::Result, 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<S, V, T, O> PreciseSumOps<[O; 4]> for Matrix4xN<V, S, T> where
    O: RealNumber,
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T> + PreciseSumOps<O>, 

fn sum_prec(&self) -> [O; 4]

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

fn sum_sq_prec(&self) -> [O; 4]

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

impl<V, S, T> RealInterpolationOps<S, T> for Matrix4xN<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: for<'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: for<'b> Buffer<'b, S, T>, 

Linear interpolation between samples.

impl<V, S, T> RealOps for Matrix4xN<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> RealToComplexTransformsOps<T> for Matrix4xN<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<<Matrix4xN<V, S, T> as ToComplexResult>::ComplexResult, (ErrorReason, <Matrix4xN<V, S, T> as ToComplexResult>::ComplexResult)>

Converts the real vector into a complex vector.

impl<V, S, T> RealToComplexTransformsOpsBuffered<S, T> for Matrix4xN<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
) -> <Matrix4xN<V, S, T> as ToComplexResult>::ComplexResult where
    B: for<'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<V, O, S, T> RededicateForceOps<Matrix4xN<O, S, T>> for Matrix4xN<V, S, T> where
    O: Vector<T>,
    S: ToSlice<T>,
    T: RealNumber,
    V: RededicateForceOps<O> + Vector<T>, 

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

Make Other a Self without performing any checks.

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

Make Other a Self without performing any checks.

impl<V, S, T> ReorganizeDataOps<T> for Matrix4xN<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<V, S, T> ResizeOps for Matrix4xN<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> ScaleOps<Complex<T>> for Matrix4xN<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 Matrix4xN<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<S, V, T> StatisticsOps<T> for Matrix4xN<V, S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T> + StatisticsOps<Statistics<T>, Result = Statistics<T>>, 

type Result = [Statistics<T>; 4]

fn statistics(&self) -> <Matrix4xN<V, S, T> as StatisticsOps<T>>::Result

Calculates the statistics of the data.

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

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

fn statistics_split(
    &self,
    len: usize
) -> Result<<Matrix4xN<V, S, T> as StatisticsSplitOps<T>>::Result, 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<V, S, T> SymmetricFrequencyToTimeDomainOperations<S, T> for Matrix4xN<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<<Matrix4xN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <Matrix4xN<V, S, T> as ToRealTimeResult>::RealTimeResult)> where
    B: for<'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<<Matrix4xN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <Matrix4xN<V, S, T> as ToRealTimeResult>::RealTimeResult)> where
    B: for<'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<<Matrix4xN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <Matrix4xN<V, S, T> as ToRealTimeResult>::RealTimeResult)> where
    B: for<'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<V, S, T> SymmetricTimeToFrequencyDomainOperations<S, T> for Matrix4xN<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<<Matrix4xN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult)> where
    B: for<'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<<Matrix4xN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult)> where
    B: for<'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<<Matrix4xN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult)> where
    B: for<'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> TimeDomainOperations<S, T> for Matrix4xN<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> TimeToFrequencyDomainOperations<S, T> for Matrix4xN<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
) -> <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult where
    B: for<'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
) -> <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult where
    B: for<'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>
) -> <Matrix4xN<V, S, T> as ToFreqResult>::FreqResult where
    B: for<'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<V, S, T> ToComplexResult for Matrix4xN<V, S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    V: Vector<T> + ToComplexResult,
    <V as ToComplexResult>::ComplexResult: Vector<T>, 

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

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

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

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

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

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

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

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

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

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

impl<S, V, T> TrigOps for Matrix4xN<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.