Struct basic_dsp::matrix::Matrix2xN

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

A matrix which can hold exactly 2 vectors.

Trait Implementations

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

pub fn ln_approx(&mut self)

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

pub fn exp_approx(&mut self)

Calculates the natural exponential approximation for every vector element.

pub fn sin_approx(&mut self)

Calculates the sine approximation of each element in radians.

pub fn cos_approx(&mut self)

Calculates the cosine approximation of each element in radians

pub fn log_approx(&mut self, base: T)

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

pub fn expf_approx(&mut self, base: T)

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

pub fn powf_approx(&mut self, exponent: T)

Raises every vector element to approximately a floating point power.

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

pub 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.

pub fn conj(&mut self)

Calculates the complex conjugate of the vector.

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

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

Copies all real elements into the given vector.

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

Copies all imag elements into the given vector.

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

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

pub 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.

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

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

pub 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.

pub 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 Matrix2xN<V, S, T> where
    N: NumberSpace,
    T: RealNumber,
    V: Vector<T> + ComplexToRealSetterOps<V, T, N, D> + GetMetaData<T, N, D>,
    S: ToSlice<T>,
    O: Matrix<V, T> + GetMetaData<T, N, D>,
    D: Domain, 

pub 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.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + ComplexToRealTransformsOps<T>,
    S: ToSlice<T>,
    <V as ToRealResult>::RealResult: Vector<T>, 

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

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

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

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

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

Gets all real elements.

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

Gets all imag elements.

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

Gets the phase of all elements in [rad].

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

pub fn magnitude_b<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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.

pub fn magnitude_squared_b<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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.

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

Gets all real elements.

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

Gets all imag elements.

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

Gets the phase of all elements in [rad].

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

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + Convolution<'a, S, T, &'a (dyn RealImpulseResponse<T> + 'a)>,
    S: ToSliceMut<T>, 

pub 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>; 2]; 2], S, T, N, D> for Matrix2xN<DspVec<S, T, N, D>, S, T> where
    N: NumberSpace,
    T: RealNumber,
    S: ToSliceMut<T>,
    D: Domain, 

pub fn convolve_signal<B>(
    &mut self,
    buffer: &mut B,
    impulse_response: &[[&'a DspVec<S, T, N, D>; 2]; 2]
) -> 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 Matrix2xN<DspVec<S, T, N, D>, S, T> where
    N: NumberSpace,
    T: RealNumber,
    S: ToSliceMut<T>,
    D: Domain,
    DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + CrossCorrelationArgumentOps<S, T>,
    S: ToSliceMut<T>,
    <V as ToFreqResult>::FreqResult: Vector<T>, 

pub fn prepare_argument<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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:

pub fn prepare_argument_padded<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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 Matrix2xN<V, S, T> where
    N: NumberSpace,
    T: RealNumber,
    V: CrossCorrelationOps<V, S, T, N, D> + GetMetaData<T, N, D> + Vector<T>,
    S: ToSliceMut<T>,
    O: Matrix<V, T> + GetMetaData<T, N, D>,
    D: Domain, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + DiffSumOps,
    S: ToSlice<T>, 

pub fn diff(&mut self)

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

pub fn diff_with_start(&mut self)

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

pub 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<Matrix2xN<V, S, T>, T, T, N, D> for Matrix2xN<V, S, T> where
    N: NumberSpace,
    T: RealNumber,
    V: Vector<T> + DotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,
    S: ToSlice<T>,
    D: Domain, 

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

pub fn dot_product(
    &self,
    factor: &Matrix2xN<V, S, T>
) -> Result<Vec<T, Global>, 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 Matrix2xN<V, S, T> where
    N: NumberSpace,
    T: RealNumber,
    V: Vector<T> + DotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,
    S: ToSlice<T>,
    D: Domain, 

type Output = Result<[T; 2], ErrorReason>

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

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

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

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

Calculates the sum of self + summand. It consumes self and returns the result.

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

Calculates the difference of self - subtrahend. It consumes self and returns the result.

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

Calculates the quotient of self / summand. It consumes self and returns the result.

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

Calculates the product of self * factor. It consumes self and returns the result.

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

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

Calculates the sum of self + summand. It consumes self and returns the result.

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

Calculates the difference of self - subtrahend. It consumes self and returns the result.

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

Calculates the quotient of self / summand. It consumes self and returns the result.

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

Calculates the product of self * factor. It consumes self and returns the result.

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

pub fn add_smaller(
    &mut self,
    summand: &Matrix2xN<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.

pub fn sub_smaller(
    &mut self,
    summand: &Matrix2xN<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.

pub fn div_smaller(
    &mut self,
    summand: &Matrix2xN<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.

pub fn mul_smaller(
    &mut self,
    summand: &Matrix2xN<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.

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

pub 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.

pub 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.

pub 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.

pub 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.

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

pub 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).

pub fn fft_shift(&mut self)

Swaps vector halves after a Fourier Transformation.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + FrequencyMultiplication<'a, S, T, &'a (dyn ComplexFrequencyResponse<T> + 'a)>,
    S: ToSliceMut<T>, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + FrequencyMultiplication<'a, S, T, &'a (dyn RealFrequencyResponse<T> + 'a)>,
    S: ToSliceMut<T>, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + FrequencyToTimeDomainOperations<S, T>,
    S: ToSliceMut<T>,
    <V as ToTimeResult>::TimeResult: Vector<T>, 

pub fn plain_ifft<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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.

pub fn ifft<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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.

pub fn windowed_ifft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> <Matrix2xN<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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T>,
    S: ToSlice<T>, 

type Output = [V; 2]

Type of the underlying storage of a matrix.

pub fn get(self) -> (<Matrix2xN<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 Matrix2xN<V, S, T> where
    N: NumberSpace,
    T: RealNumber,
    V: Vector<T> + GetMetaData<T, N, D>,
    S: ToSlice<T>,
    D: Domain, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + InterpolationOps<S, T>,
    S: ToSliceMut<T>, 

pub 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().

pub 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.

pub 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.

pub 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.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    R: Send,
    V: Vector<T> + MapAggregateOps<T, R, Output = Result<R, ErrorReason>>,
    S: ToSlice<T>, 

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

pub fn map_aggregate<'a, A, FMap, FAggr>(
    &self,
    argument: A,
    map: &FMap,
    aggregate: &FAggr
) -> Result<[R; 2], ErrorReason> where
    R: Send,
    A: Sync + Copy + Send,
    FMap: Fn(T, usize, A) -> R + 'a + Sync,
    FAggr: Fn(R, R) -> R + 'a + Sync + 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + MapInplaceOps<Complex<T>>,
    S: ToSlice<T>, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + MapInplaceOps<T>,
    S: ToSlice<T>, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T>,
    S: ToSlice<T>, 

pub 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].

pub 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].

pub fn row_len(&self) -> usize

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

pub 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.

pub fn col_len(&self) -> usize

The number of columns in the matrix.

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

Gets the rows as vectors.

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

Gets the rows as mutable vectors.

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

pub 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.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + ModuloOps<T>,
    S: ToSlice<T>, 

pub 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.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + OffsetOps<Complex<T>>,
    S: ToSlice<T>, 

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

Adds a scalar to each vector element.

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

pub fn offset(&mut self, offset: T)

Adds a scalar to each vector element.

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

pub fn sqrt(&mut self)

Gets the square root of all vector elements.

pub fn square(&mut self)

Squares all vector elements.

pub fn root(&mut self, degree: T)

Calculates the n-th root of every vector element.

pub fn powf(&mut self, exponent: T)

Raises every vector element to a floating point power.

pub fn ln(&mut self)

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

pub fn exp(&mut self)

Calculates the natural exponential for every vector element.

pub fn log(&mut self, base: T)

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

pub fn expf(&mut self, base: T)

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

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

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

pub fn dot_product_prec(
    &self,
    factor: &Matrix2xN<V, S, T>
) -> Result<Vec<T, Global>, 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 Matrix2xN<V, S, T> where
    N: NumberSpace,
    T: RealNumber,
    V: Vector<T> + PreciseDotProductOps<V, T, T, N, D, Output = Result<T, ErrorReason>> + GetMetaData<T, N, D>,
    S: ToSlice<T>,
    D: Domain, 

type Output = Result<[T; 2], ErrorReason>

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

type Result = [Statistics<T>; 2]

pub fn statistics_prec(
    &self
) -> <Matrix2xN<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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + PreciseStatisticsSplitOps<Statistics<T>, Result = ArrayVec<Statistics<T>, {_: usize}>>,
    S: ToSlice<T>, 

type Result = [ArrayVec<Statistics<T>, {_: usize}>; 2]

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

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

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

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

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

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

pub 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.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + RealOps,
    S: ToSlice<T>, 

pub fn abs(&mut self)

Gets the absolute value of all vector elements.

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

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

Converts the real vector into a complex vector.

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

pub fn to_complex_b<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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<Matrix2xN<O, S, T>> for Matrix2xN<V, S, T> where
    T: RealNumber,
    V: RededicateForceOps<O> + Vector<T>,
    S: ToSlice<T>,
    O: Vector<T>, 

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

Make Other a Self without performing any checks.

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

Make Other a Self without performing any checks.

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

pub fn reverse(&mut self)

Reverses the data inside the vector.

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T>,
    S: ToSlice<T>, 

pub 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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + ScaleOps<Complex<T>>,
    S: ToSlice<T>, 

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

Multiplies the vector element with a scalar.

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

pub fn scale(&mut self, factor: T)

Multiplies the vector element with a scalar.

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

type Result = [Statistics<T>; 2]

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

Calculates the statistics of the data.

impl<S, V, T> StatisticsSplitOps<T> for Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + StatisticsSplitOps<Statistics<T>, Result = ArrayVec<Statistics<T>, {_: usize}>>,
    S: ToSlice<T>, 

type Result = [ArrayVec<Statistics<T>, {_: usize}>; 2]

pub fn statistics_split(
    &self,
    len: usize
) -> Result<<Matrix2xN<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<S, V, T> SumOps<[T; 2]> for Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + SumOps<T>,
    S: ToSlice<T>, 

pub fn sum(&self) -> [T; 2]

Calculates the sum of the data contained in the vector.

pub fn sum_sq(&self) -> [T; 2]

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

impl<S, V, T> SumOps<[T; 3]> for Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + SumOps<T>,
    S: ToSlice<T>, 

pub fn sum(&self) -> [T; 3]

Calculates the sum of the data contained in the vector.

pub fn sum_sq(&self) -> [T; 3]

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

impl<S, V, T> SumOps<[T; 4]> for Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + SumOps<T>,
    S: ToSlice<T>, 

pub fn sum(&self) -> [T; 4]

Calculates the sum of the data contained in the vector.

pub fn sum_sq(&self) -> [T; 4]

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

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

pub fn plain_sifft<B>(
    self,
    buffer: &mut B
) -> Result<<Matrix2xN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <Matrix2xN<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.

pub fn sifft<B>(
    self,
    buffer: &mut B
) -> Result<<Matrix2xN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <Matrix2xN<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.

pub fn windowed_sifft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> Result<<Matrix2xN<V, S, T> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <Matrix2xN<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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + SymmetricTimeToFrequencyDomainOperations<S, T>,
    S: ToSliceMut<T>,
    <V as ToFreqResult>::FreqResult: Vector<T>, 

pub fn plain_sfft<B>(
    self,
    buffer: &mut B
) -> Result<<Matrix2xN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <Matrix2xN<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.

pub fn sfft<B>(
    self,
    buffer: &mut B
) -> Result<<Matrix2xN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <Matrix2xN<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.

pub fn windowed_sfft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> Result<<Matrix2xN<V, S, T> as ToFreqResult>::FreqResult, (ErrorReason, <Matrix2xN<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.

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

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

Applies a window to the data vector.

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

Removes a window from the data vector.

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

pub fn plain_fft<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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.

pub fn fft<B>(
    self,
    buffer: &mut B
) -> <Matrix2xN<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.

pub fn windowed_fft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> <Matrix2xN<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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + ToComplexResult,
    S: ToSlice<T>,
    <V as ToComplexResult>::ComplexResult: Vector<T>, 

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

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

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

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

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

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

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

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

type TimeResult = Matrix2xN<<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 Matrix2xN<V, S, T> where
    T: RealNumber,
    V: Vector<T> + TrigOps,
    S: ToSlice<T>, 

pub fn sin(&mut self)

Calculates the sine of each element in radians.

pub fn cos(&mut self)

Calculates the cosine of each element in radians.

pub fn tan(&mut self)

Calculates the tangent of each element in radians.

pub fn asin(&mut self)

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

pub fn acos(&mut self)

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

pub fn atan(&mut self)

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

pub fn sinh(&mut self)

Calculates the hyperbolic sine each element in radians.

pub fn cosh(&mut self)

Calculates the hyperbolic cosine each element in radians.

pub fn tanh(&mut self)

Calculates the hyperbolic tangent each element in radians.

pub fn asinh(&mut self)

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

pub fn acosh(&mut self)

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

pub fn atanh(&mut self)

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