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<V, S, T> Matrix<V, T> for Matrix2xN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    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> 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.

fn get(self) -> (Self::Output, usize)

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

impl<V: Vector<T>, S: ToSlice<T>, T: RealNumber> ReorganizeDataOps<T> for Matrix2xN<V, S, T> where
    V: 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: ToSlice<T>, V: Vector<T> + MapInplaceOps<T>, T: RealNumber> MapInplaceOps<T> for Matrix2xN<V, S, 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: ToSlice<T>, V: Vector<T> + MapInplaceOps<Complex<T>>, T: RealNumber> MapInplaceOps<Complex<T>> for Matrix2xN<V, S, 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<V, S, T> ResizeOps for Matrix2xN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    V: Vector<T>, 

fn resize(&mut self, len: usize) -> VoidResult

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: Vector<T>, S: ToSliceMut<T>, T: RealNumber> RealToComplexTransformsOpsBuffered<S, T> for Matrix2xN<V, S, T> where
    <V as ToComplexResult>::ComplexResult: Vector<T>,
    V: RealToComplexTransformsOpsBuffered<S, T>, 

fn to_complex_b<B>(self, buffer: &mut B) -> Self::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, S, T> MetaData for Matrix2xN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    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: ToSlice<T>, V: Vector<T>, T: RealNumber> SumOps<[T; 2]> for Matrix2xN<V, S, T> where
    V: SumOps<T>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn prepare_argument<B>(self, buffer: &mut B) -> Self::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) -> Self::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<V: Vector<T> + ToRealResult, S: ToSlice<T>, T: RealNumber> ToRealResult for Matrix2xN<V, S, T> where
    <V as ToRealResult>::RealResult: Vector<T>, 

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

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

fn plain_sifft<B>(self, buffer: &mut B) -> TransRes<Self::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) -> TransRes<Self::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>
) -> TransRes<Self::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: Vector<T>, S: ToSlice<T>, T: RealNumber, N: NumberSpace, D: Domain, O> ComplexToRealSetterOps<O, T, N, D> for Matrix2xN<V, S, T> where
    O: Matrix<V, T> + GetMetaData<T, N, D>,
    V: ComplexToRealSetterOps<V, T, N, D> + GetMetaData<T, N, D>, 

fn set_real_imag(&mut self, real: &O, imag: &O) -> VoidResult

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) -> VoidResult

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

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

fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> VoidResult 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: ToSlice<T>, V: Vector<T>, T: RealNumber, R: Send> MapAggregateOps<T, R> for Matrix2xN<V, S, T> where
    V: MapAggregateOps<T, R, Output = ScalarResult<R>>, 

type Output = ScalarResult<[R; 2]>

fn map_aggregate<'a, A, FMap, FAggr>(
    &self,
    argument: A,
    map: &FMap,
    aggregate: &FAggr
) -> ScalarResult<[R; 2]> where
    A: Sync + Copy + Send,
    FMap: Fn(T, usize, A) -> R + 'a + Sync,
    FAggr: Fn(R, R) -> R + 'a + Sync + Send,
    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: ToSlice<T>, V: Vector<T> + PowerOps<T>, T: RealNumber> PowerOps<T> for Matrix2xN<V, S, 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: Vector<T>, S: ToSliceMut<T>, T: RealNumber> TimeToFrequencyDomainOperations<S, T> for Matrix2xN<V, S, T> where
    <V as ToFreqResult>::FreqResult: Vector<T>,
    V: TimeToFrequencyDomainOperations<S, T>, 

fn plain_fft<B>(self, buffer: &mut B) -> Self::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) -> Self::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>
) -> Self::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: Vector<T>, S: ToSlice<T>, T: RealNumber> RealOps for Matrix2xN<V, S, T> where
    V: RealOps, 

fn abs(&mut self)

Gets the absolute value of all vector elements. # Example

impl<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> TimeDomainOperations<S, T> for Matrix2xN<V, S, T> where
    V: 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<S: ToSlice<T>, V: Vector<T>, T: RealNumber> StatisticsSplitOps<T> for Matrix2xN<V, S, T> where
    V: StatisticsSplitOps<Statistics<T>, Result = StatsVec<Statistics<T>>>, 

type Result = [StatsVec<Statistics<T>>; 2]

fn statistics_split(&self, len: usize) -> ScalarResult<Self::Result>

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: ToSlice<T>, V: Vector<T>, T: RealNumber, O: RealNumber> PreciseSumOps<[O; 2]> for Matrix2xN<V, S, T> where
    V: PreciseSumOps<O>, 

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

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

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. # Example

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

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

Multiplies self with the frequency response function frequency_response.

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

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

Multiplies self with the frequency response function frequency_response.

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

type Result = [Statistics<T>; 2]

fn statistics_prec(&self) -> Self::Result

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

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

fn convolve<B>(
    &mut self,
    buffer: &mut B,
    impulse_response: &'a dyn RealImpulseResponse<T>,
    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: Vector<T>, S: ToSliceMut<T>, T: RealNumber> Convolution<'a, S, T, &'a (dyn ComplexImpulseResponse<T> + 'a)> for Matrix2xN<V, S, T> where
    V: Convolution<'a, S, T, &'a dyn ComplexImpulseResponse<T>>, 

fn convolve<B>(
    &mut self,
    buffer: &mut B,
    impulse_response: &'a dyn ComplexImpulseResponse<T>,
    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<S: ToSlice<T>, V: Vector<T> + ApproximatedOps<T>, T: RealNumber> ApproximatedOps<T> for Matrix2xN<V, S, 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<S: ToSlice<T>, V: Vector<T>, T: RealNumber, N: NumberSpace, D: Domain> DotProductOps<Matrix2xN<V, S, T>, T, T, N, D> for Matrix2xN<V, S, T> where
    V: DotProductOps<V, T, T, N, D, Output = ScalarResult<T>> + GetMetaData<T, N, D>, 

type Output = ScalarResult<Vec<T>>

fn dot_product(&self, factor: &Matrix2xN<V, S, T>) -> ScalarResult<Vec<T>>

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

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

type Output = ScalarResult<[T; 2]>

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

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

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

fn scale(&mut self, factor: T)

Multiplies the vector element with a scalar.

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

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

Multiplies the vector element with a scalar.

impl<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> FrequencyDomainOperations<S, T> for Matrix2xN<V, S, T> where
    V: 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<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> RealInterpolationOps<S, T> for Matrix2xN<V, S, T> where
    V: 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: Vector<T>, S: ToSlice<T>, T: RealNumber> ComplexOps<T> for Matrix2xN<V, S, T> where
    V: 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: Vector<T> + ToTimeResult, S: ToSlice<T>, T: RealNumber> ToTimeResult for Matrix2xN<V, S, T> where
    <V as ToTimeResult>::TimeResult: Vector<T>, 

type TimeResult = Matrix2xN<V::TimeResult, S, T>

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

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

fn magnitude_b<B>(self, buffer: &mut B) -> Self::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) -> Self::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) -> Self::RealResult where
    B: for<'b> Buffer<'b, S, T>, 

Gets all real elements. # Example

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

Gets all imag elements. # Example

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

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

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

type Output = ScalarResult<Vec<T>>

fn dot_product_prec(&self, factor: &Matrix2xN<V, S, T>) -> ScalarResult<Vec<T>>

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

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

type Output = ScalarResult<[T; 2]>

fn dot_product_prec(&self, factor: &V) -> ScalarResult<[T; 2]>

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

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

fn plain_sfft<B>(self, buffer: &mut B) -> TransRes<Self::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) -> TransRes<Self::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>
) -> TransRes<Self::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: Vector<T>, S: ToSlice<T>, T: RealNumber> ComplexToRealTransformsOps<T> for Matrix2xN<V, S, T> where
    <V as ToRealResult>::RealResult: Vector<T>,
    V: ComplexToRealTransformsOps<T>, 

fn magnitude(self) -> Self::RealResult

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

fn magnitude_squared(self) -> Self::RealResult

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

fn to_real(self) -> Self::RealResult

Gets all real elements. # Example

fn to_imag(self) -> Self::RealResult

Gets all imag elements. # Example

fn phase(self) -> Self::RealResult

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

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

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

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

Make Other a Self without performing any checks.

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

Make Other a Self without performing any checks.

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

type Result = [StatsVec<Statistics<T>>; 2]

fn statistics_split_prec(&self, len: usize) -> ScalarResult<Self::Result>

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: Vector<T> + ToRealTimeResult, S: ToSlice<T>, T: RealNumber> ToRealTimeResult for Matrix2xN<V, S, T> where
    <V as ToRealTimeResult>::RealTimeResult: Vector<T>, 

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

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

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

impl<S: ToSliceMut<T>, T: RealNumber, N: NumberSpace, D: Domain> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix2xN<DspVec<S, T, N, D>, S, T> where
    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>
) -> VoidResult 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<'a, S: ToSliceMut<T>, T: RealNumber, N: NumberSpace, D: Domain> ConvolutionOps<[[&'a DspVec<S, T, N, D>; 2]; 2], S, T, N, D> for Matrix2xN<DspVec<S, T, N, D>, S, T>

fn convolve_signal<B>(
    &mut self,
    buffer: &mut B,
    impulse_response: &[[&'a DspVec<S, T, N, D>; 2]; 2]
) -> VoidResult 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: Vector<T> + ToFreqResult, S: ToSlice<T>, T: RealNumber> ToFreqResult for Matrix2xN<V, S, T> where
    <V as ToFreqResult>::FreqResult: Vector<T>, 

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

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

fn to_complex(self) -> TransRes<Self::ComplexResult>

Converts the real vector into a complex vector.

impl<V: Vector<T>, S: ToSlice<T>, T: RealNumber> ModuloOps<T> for Matrix2xN<V, S, T> where
    V: 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: Vector<T>, S: ToSlice<T>, T: RealNumber> OffsetOps<T> for Matrix2xN<V, S, T> where
    V: OffsetOps<T>, 

fn offset(&mut self, offset: T)

Adds a scalar to each vector element.

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

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

Adds a scalar to each vector element.

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

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: ToSlice<T>, V: Vector<T>, T: RealNumber> StatisticsOps<T> for Matrix2xN<V, S, T> where
    V: StatisticsOps<Statistics<T>, Result = Statistics<T>>, 

type Result = [Statistics<T>; 2]

fn statistics(&self) -> Self::Result

Calculates the statistics of the data.

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

fn add(&mut self, summand: &Self) -> VoidResult

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: &Self) -> VoidResult

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: &Self) -> VoidResult

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: &Self) -> VoidResult

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

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

fn add(&mut self, summand: &V) -> VoidResult

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) -> VoidResult

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) -> VoidResult

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) -> VoidResult

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

impl<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> InterpolationOps<S, T> for Matrix2xN<V, S, T> where
    V: 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
) -> VoidResult 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
) -> VoidResult 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<V: Vector<T>, S: ToSlice<T>, T: RealNumber, N: NumberSpace, D: Domain> ElementaryWrapAroundOps<Matrix2xN<V, S, T>, T, N, D> for Matrix2xN<V, S, T> where
    V: ElementaryWrapAroundOps<V, T, N, D> + GetMetaData<T, N, D>, 

fn add_smaller(&mut self, summand: &Self) -> VoidResult

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: &Self) -> VoidResult

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: &Self) -> VoidResult

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: &Self) -> VoidResult

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

fn add_smaller(&mut self, summand: &V) -> VoidResult

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) -> VoidResult

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) -> VoidResult

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) -> VoidResult

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: ToSlice<T>, V: Vector<T> + TrigOps, T: RealNumber> TrigOps for Matrix2xN<V, S, T>

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.