Struct basic_dsp_matrix::Matrix3xN

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

A matrix which can hold exactly 3 vectors.

Trait Implementations

impl<V, S, T> Matrix<V, T> for Matrix3xN<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 Matrix3xN<V, S, T> where     T: RealNumber,     V: Vector<T>,     S: ToSlice<T>,

type Output = [V; 3]

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> + ToFreqResult, S: ToSlice<T>, T: RealNumber> ToFreqResult for Matrix3xN<V, S, T> where     <V as ToFreqResult>::FreqResult: Vector<T>,

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

impl<S: ToSlice<T>, V: Vector<T>, T: RealNumber, R: Send> MapAggregateOps<T, R> for Matrix3xN<V, S, T> where     V: MapAggregateOps<T, R, Output = ScalarResult<R>>,

type Output = ScalarResult<[R; 3]>

fn map_aggregate<'a, A, FMap, FAggr>(     &self,     argument: A,     map: &FMap,     aggregate: &FAggr ) -> ScalarResult<[R; 3]> 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<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> TimeDomainOperations<S, T> for Matrix3xN<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<V: Vector<T>, S: ToSlice<T>, T: RealNumber, N: NumberSpace, D: Domain, O> ComplexToRealGetterOps<O, T, N, D> for Matrix3xN<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: ToSlice<T>, V: Vector<T> + MapInplaceOps<T>, T: RealNumber> MapInplaceOps<T> for Matrix3xN<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 Matrix3xN<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: Vector<T>, S: ToSlice<T>, T: RealNumber> ComplexToRealTransformsOps<T> for Matrix3xN<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: ToSlice<T>, T: RealNumber> RealToComplexTransformsOps<T> for Matrix3xN<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<S: ToSlice<T>, V: Vector<T> + DiffSumOps, T: RealNumber> DiffSumOps for Matrix3xN<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: ToSliceMut<T>, T: RealNumber> RealToComplexTransformsOpsBuffered<S, T> for Matrix3xN<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: Vector<T>, S: ToSliceMut<T>, T: RealNumber> SymmetricFrequencyToTimeDomainOperations<S, T> for Matrix3xN<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<S: ToSlice<T>, V: Vector<T>, T: RealNumber> StatisticsSplitOps<T> for Matrix3xN<V, S, T> where     V: StatisticsSplitOps<Statistics<T>, Result = StatsVec<Statistics<T>>>,

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

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<'a, V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> Convolution<'a, S, T, &'a (dyn RealImpulseResponse<T> + 'a)> for Matrix3xN<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 Matrix3xN<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<V, S, T, N, D> GetMetaData<T, N, D> for Matrix3xN<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, O: RealNumber> PreciseSumOps<[O; 3]> for Matrix3xN<V, S, T> where     V: PreciseSumOps<O>,

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

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

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

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

impl<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> TimeToFrequencyDomainOperations<S, T> for Matrix3xN<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<S: ToSlice<T>, V: Vector<T>, T: RealNumber> PreciseStatisticsOps<T> for Matrix3xN<V, S, T> where     V: PreciseStatisticsOps<Statistics<T>, Result = Statistics<T>>,

type Result = [Statistics<T>; 3]

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

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

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

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

impl<V: Vector<T>, S: ToSlice<T>, T: RealNumber, N: NumberSpace, D: Domain> ElementaryWrapAroundOps<Matrix3xN<V, S, T>, T, N, D> for Matrix3xN<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 Matrix3xN<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<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> InterpolationOps<S, T> for Matrix3xN<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<S: ToSlice<T>, V: Vector<T> + TrigOps, T: RealNumber> TrigOps for Matrix3xN<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.

impl<V: Vector<T>, S: ToSlice<T>, T: RealNumber> ReorganizeDataOps<T> for Matrix3xN<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<V, O, S: ToSlice<T>, T: RealNumber> RededicateForceOps<Matrix3xN<O, S, T>> for Matrix3xN<V, S, T> where     V: RededicateForceOps<O> + Vector<T>,     T: RealNumber,     O: Vector<T>,

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

Make Other a Self without performing any checks.

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

Make Other a Self without performing any checks.

impl<S: ToSlice<T>, V: Vector<T> + ApproximatedOps<T>, T: RealNumber> ApproximatedOps<T> for Matrix3xN<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<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> RealInterpolationOps<S, T> for Matrix3xN<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, N: NumberSpace, D: Domain, O> ComplexToRealSetterOps<O, T, N, D> for Matrix3xN<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<V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> FrequencyDomainOperations<S, T> for Matrix3xN<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: ToSlice<T>, T: RealNumber> ModuloOps<T> for Matrix3xN<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> + ToTimeResult, S: ToSlice<T>, T: RealNumber> ToTimeResult for Matrix3xN<V, S, T> where     <V as ToTimeResult>::TimeResult: Vector<T>,

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

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

impl<S: ToSlice<T>, V: Vector<T>, T: RealNumber, N: NumberSpace, D: Domain> PreciseDotProductOps<Matrix3xN<V, S, T>, T, T, N, D> for Matrix3xN<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: &Matrix3xN<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 Matrix3xN<V, S, T> where     V: PreciseDotProductOps<V, T, T, N, D, Output = ScalarResult<T>> + GetMetaData<T, N, D>,

type Output = ScalarResult<[T; 3]>

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

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> ComplexToRealTransformsOpsBuffered<S, T> for Matrix3xN<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> PreciseStatisticsSplitOps<T> for Matrix3xN<V, S, T> where     V: PreciseStatisticsSplitOps<Statistics<T>, Result = StatsVec<Statistics<T>>>,

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

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

type Result = [Statistics<T>; 3]

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

Calculates the statistics of the data.

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

fn abs(&mut self)

Gets the absolute value of all vector elements. # Example

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

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

impl<S: ToSliceMut<T>, T: RealNumber, N: NumberSpace, D: Domain, O, V> CrossCorrelationOps<O, S, T, N, D> for Matrix3xN<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, N: NumberSpace, D: Domain> DotProductOps<Matrix3xN<V, S, T>, T, T, N, D> for Matrix3xN<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: &Matrix3xN<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 Matrix3xN<V, S, T> where     V: DotProductOps<V, T, T, N, D, Output = ScalarResult<T>> + GetMetaData<T, N, D>,

type Output = ScalarResult<[T; 3]>

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

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

impl<V, S, T> MetaData for Matrix3xN<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> + PowerOps<T>, T: RealNumber> PowerOps<T> for Matrix3xN<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> + ToComplexResult, S: ToSlice<T>, T: RealNumber> ToComplexResult for Matrix3xN<V, S, T> where     <V as ToComplexResult>::ComplexResult: Vector<T>,

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

impl<V: Vector<T> + ScaleOps<T>, S: ToSlice<T>, T: RealNumber> ScaleOps<T> for Matrix3xN<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 Matrix3xN<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> CrossCorrelationArgumentOps<S, T> for Matrix3xN<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<S: ToSliceMut<T>, T: RealNumber, N: NumberSpace, D: Domain> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix3xN<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>; 3]; 3], S, T, N, D> for Matrix3xN<DspVec<S, T, N, D>, S, T>

fn convolve_signal<B>(     &mut self,     buffer: &mut B,     impulse_response: &[[&'a DspVec<S, T, N, D>; 3]; 3] ) -> 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>, S: ToSliceMut<T>, T: RealNumber> SymmetricTimeToFrequencyDomainOperations<S, T> for Matrix3xN<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, N: NumberSpace, D: Domain> ElementaryOps<Matrix3xN<V, S, T>, T, N, D> for Matrix3xN<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 Matrix3xN<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: ToSlice<T>, T: RealNumber> ComplexOps<T> for Matrix3xN<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>, S: ToSliceMut<T>, T: RealNumber> FrequencyToTimeDomainOperations<S, T> for Matrix3xN<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, S, T> ResizeOps for Matrix3xN<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<'a, V: Vector<T>, S: ToSliceMut<T>, T: RealNumber> FrequencyMultiplication<'a, S, T, &'a (dyn RealFrequencyResponse<T> + 'a)> for Matrix3xN<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 Matrix3xN<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<V: Vector<T>, S: ToSlice<T>, T: RealNumber> OffsetOps<T> for Matrix3xN<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 Matrix3xN<V, S, T> where     V: OffsetOps<Complex<T>>,

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

Adds a scalar to each vector element.