Struct basic_dsp_vector::DspVec

pub struct DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain,  {
    pub data: S,
    // some fields omitted
}

A 1xN (one times N elements) or Nx1 data vector as used for most digital signal processing (DSP) operations.

Vectors come in different flavors:

1. Time or Frequency domain
2. Real or Complex numbers
3. 32bit or 64bit floating point numbers

The first two flavors define meta information about the vector and provide compile time information what operations are available with the given vector and how this will transform the vector. This makes sure that some invalid operations are already discovered at compile time. In case that this isn’t desired or the information about the vector isn’t known at compile time there are the generic DataVec32 and DataVec64 vectors available.

32bit and 64bit flavors trade performance and memory consumption against accuracy. 32bit vectors are roughly two times faster than 64bit vectors for most operations. But remember that you should benchmark first before you give away accuracy for performance unless however you are sure that 32bit accuracy is certainly good enough.

Fields

data: S

The underlying storage. self.len() should be called to find out how many elements in data contain valid data.

Implementations

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

pub fn convolve_mat(
    matrix: &[&Self],
    impulse_response: &[&Self],
    target: &mut [T]
) -> VoidResult

Convolves a vector of vectors (in this lib also considered a matrix) with a vector of impulse responses and stores the result in target.

impl<S: ToSliceMut<T>, T: RealNumber> DspVec<S, T, RealOrComplex, TimeOrFreq>

pub fn is_erroneous(&self) -> bool

Indicates whether or not the operations on this vector have been successful. Consider using the statically typed vector versions so that this check doesn’t need to be performed.

Trait Implementations

impl<S, T, N, D> ApproximatedOps<T> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

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, T, N, D> Clone for DspVec<S, T, N, D> where
    S: ToSlice<T> + Clone,
    T: RealNumber,
    N: NumberSpace + Clone,
    D: Domain + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, T, N, D> ComplexIndex<Range<usize>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Output = [Complex<T>]

fn datac(&self, index: Range<usize>) -> &[Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndex<RangeFrom<usize>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Output = [Complex<T>]

fn datac(&self, index: RangeFrom<usize>) -> &[Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndex<RangeFull> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Output = [Complex<T>]

fn datac(&self, _index: RangeFull) -> &[Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndex<RangeTo<usize>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Output = [Complex<T>]

fn datac(&self, index: RangeTo<usize>) -> &[Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndex<usize> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Output = Complex<T>

fn datac(&self, index: usize) -> &Complex<T>

The method for complex indexing

impl<S, T, N, D> ComplexIndexMut<Range<usize>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn datac_mut(&mut self, index: Range<usize>) -> &mut [Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndexMut<RangeFrom<usize>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn datac_mut(&mut self, index: RangeFrom<usize>) -> &mut [Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndexMut<RangeFull> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn datac_mut(&mut self, _index: RangeFull) -> &mut [Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndexMut<RangeTo<usize>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn datac_mut(&mut self, index: RangeTo<usize>) -> &mut [Complex<T>]

The method for complex indexing

impl<S, T, N, D> ComplexIndexMut<usize> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn datac_mut(&mut self, index: usize) -> &mut Complex<T>

The method for complex indexing

impl<S, T, N, D> ComplexOps<T> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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.

impl<S, T, N, NR, D, O, DO> ComplexToRealGetterOps<O, T, NR, DO> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToRealResult,
    O: Vector<T> + GetMetaData<T, NR, DO> + FloatIndex<Range<usize>, Output = [T]> + FloatIndexMut<Range<usize>>,
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    NR: RealNumberSpace,
    D: Domain,
    DO: PosEq<D> + Domain, 

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

Copies all real elements into the given vector.

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

Copies all imag elements into the given vector.

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

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

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.

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

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

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

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

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

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

impl<S, T, N, NR, D, O, DO> ComplexToRealSetterOps<O, T, NR, DO> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToRealResult,
    O: FloatIndex<Range<usize>, Output = [T]> + Vector<T> + GetMetaData<T, NR, DO>,
    S: ToSliceMut<T> + Resize,
    T: RealNumber,
    N: ComplexNumberSpace,
    NR: RealNumberSpace,
    D: Domain,
    DO: PosEq<D> + Domain, 

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, T, N, D> ComplexToRealTransformsOps<T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToRealResult,
    <DspVec<S, T, N, D> as ToRealResult>::RealResult: RededicateForceOps<DspVec<S, T, N, D>>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn magnitude(self) -> Self::RealResult

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

fn magnitude_squared(self) -> Self::RealResult

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

fn to_real(self) -> Self::RealResult

Gets all real elements.

fn to_imag(self) -> Self::RealResult

Gets all imag elements.

fn phase(self) -> Self::RealResult

Gets the phase of all elements in [rad].

impl<S, T, N, D> ComplexToRealTransformsOpsBuffered<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToRealResult,
    <DspVec<S, T, N, D> as ToRealResult>::RealResult: RededicateForceOps<DspVec<S, T, N, D>>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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

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

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

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

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

Gets all real elements.

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

Gets all imag elements.

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

Gets the phase of all elements in [rad].

impl<'a, S, T, N, D> Convolution<'a, S, T, &'a (dyn ComplexImpulseResponse<T> + 'a)> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: TimeDomain,
    DspVec<S, T, N, D>: TimeToFrequencyDomainOperations<S, T> + Clone + ConvolutionOps<DspVec<InlineVector<T>, T, N, D>, S, T, N, D>, 

fn convolve<B>(
    &mut self,
    buffer: &mut B,
    function: &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<'a, S, T, N, D> Convolution<'a, S, T, &'a (dyn RealImpulseResponse<T> + 'a)> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: TimeDomain,
    DspVec<S, T, N, D>: TimeToFrequencyDomainOperations<S, T> + Clone + ConvolutionOps<DspVec<InlineVector<T>, T, N, D>, S, T, N, D>, 

fn convolve<B>(
    &mut self,
    buffer: &mut B,
    function: &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<S, SO, T, N, D, NO, DO> ConvolutionOps<DspVec<SO, T, NO, DO>, S, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    SO: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: TimeDomain,
    DspVec<S, T, N, D>: TimeToFrequencyDomainOperations<S, T> + Clone,
    DspVec<SO, T, N, D>: TimeToFrequencyDomainOperations<SO, T> + Clone,
    NO: PosEq<N> + NumberSpace,
    DO: TimeDomain, 

fn convolve_signal<B>(
    &mut self,
    buffer: &mut B,
    impulse_response: &DspVec<SO, T, NO, DO>
) -> VoidResult where
    B: for<'a> Buffer<'a, 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> CrossCorrelationArgumentOps<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToFreqResult + TimeToFrequencyDomainOperations<S, T>,
    <DspVec<S, T, N, D> as ToFreqResult>::FreqResult: FrequencyDomainOperations<S, T> + ComplexOps<T>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: TimeDomain, 

fn prepare_argument<B>(self, buffer: &mut B) -> Self::FreqResult where
    B: for<'a> Buffer<'a, 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<'a> Buffer<'a, 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, DF, O, NO> CrossCorrelationOps<O, S, T, NO, DF> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ScaleOps<T>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: TimeDomain,
    DF: FrequencyDomain,
    O: Vector<T> + GetMetaData<T, NO, DF>,
    NO: PosEq<N> + NumberSpace, 

fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> VoidResult where
    B: for<'a> Buffer<'a, 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, T, N, D> Debug for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain,
    N: NumberSpace, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

fn diff(&mut self)

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

fn diff_with_start(&mut self)

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

fn cum_sum(&mut self)

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

impl<S, O, T, N, D, NO, DO> DotProductOps<O, Complex<T>, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain,
    O: Vector<T> + GetMetaData<T, NO, DO>,
    NO: PosEq<N> + NumberSpace,
    DO: PosEq<D> + Domain, 

type Output = ScalarResult<Complex<T>>

fn dot_product(&self, factor: &O) -> ScalarResult<Complex<T>>

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

impl<S, O, T, N, D, NO, DO> DotProductOps<O, T, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain,
    O: Vector<T> + GetMetaData<T, NO, DO>,
    NO: PosEq<N> + NumberSpace,
    DO: PosEq<D> + Domain, 

type Output = ScalarResult<T>

fn dot_product(&self, factor: &O) -> ScalarResult<T>

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

impl<S, T, N, D, O, NO, DO> ElementaryOps<O, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain,
    O: Vector<T> + GetMetaData<T, NO, DO>,
    NO: PosEq<N> + NumberSpace,
    DO: PosEq<D> + Domain, 

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

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

fn sub(&mut self, subtrahend: &O) -> VoidResult

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

fn mul(&mut self, factor: &O) -> VoidResult

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

fn div(&mut self, divisor: &O) -> VoidResult

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

impl<S, T, N, D, O, NO, DO> ElementaryWrapAroundOps<O, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain,
    O: Vector<T> + GetMetaData<T, NO, DO>,
    NO: PosEq<N> + NumberSpace,
    DO: PosEq<D> + Domain, 

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

fn sub_smaller(&mut self, subtrahend: &O) -> 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.

fn mul_smaller(&mut self, factor: &O) -> 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.

fn div_smaller(&mut self, divisor: &O) -> 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.

impl<S, T, N, D> FloatIndex<Range<usize>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

type Output = [T]

fn data(&self, index: Range<usize>) -> &[T]

The method for float indexing. If the vector is real valued then this function just returns the values

impl<S, T, N, D> FloatIndex<RangeFrom<usize>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

type Output = [T]

fn data(&self, index: RangeFrom<usize>) -> &[T]

The method for float indexing. If the vector is real valued then this function just returns the values

impl<S, T, N, D> FloatIndex<RangeFull> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

type Output = [T]

fn data(&self, _index: RangeFull) -> &[T]

The method for float indexing. If the vector is real valued then this function just returns the values

impl<S, T, N, D> FloatIndex<RangeTo<usize>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

type Output = [T]

fn data(&self, index: RangeTo<usize>) -> &[T]

The method for float indexing. If the vector is real valued then this function just returns the values

impl<S, T, N, D> FloatIndex<usize> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

type Output = T

fn data(&self, index: usize) -> &T

The method for float indexing. If the vector is real valued then this function just returns the values

impl<S, T, N, D> FloatIndexMut<Range<usize>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn data_mut(&mut self, index: Range<usize>) -> &mut [T]

The method for real indexing

impl<S, T, N, D> FloatIndexMut<RangeFrom<usize>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn data_mut(&mut self, index: RangeFrom<usize>) -> &mut [T]

The method for real indexing

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

fn data_mut(&mut self, _index: RangeFull) -> &mut [T]

The method for real indexing

impl<S, T, N, D> FloatIndexMut<RangeTo<usize>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn data_mut(&mut self, index: RangeTo<usize>) -> &mut [T]

The method for real indexing

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

fn data_mut(&mut self, index: usize) -> &mut T

The method for real indexing

impl<S, T, N, D> FrequencyDomainOperations<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToTimeResult,
    <DspVec<S, T, N, D> as ToTimeResult>::TimeResult: RededicateForceOps<DspVec<S, T, N, D>>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: FrequencyDomain, 

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

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

fn fft_shift(&mut self)

Swaps vector halves after a Fourier Transformation.

fn ifft_shift(&mut self)

Swaps vector halves before an Inverse Fourier Transformation.

impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a (dyn ComplexFrequencyResponse<T> + 'a)> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: FrequencyDomain, 

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

Multiplies self with the frequency response function frequency_response.

impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a (dyn RealFrequencyResponse<T> + 'a)> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: FrequencyDomain, 

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

Multiplies self with the frequency response function frequency_response.

impl<S, T, N, D> FrequencyToTimeDomainOperations<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToTimeResult,
    <DspVec<S, T, N, D> as ToTimeResult>::TimeResult: RededicateForceOps<DspVec<S, T, N, D>> + TimeDomainOperations<S, T>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: FrequencyDomain, 

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

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

fn windowed_ifft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> Self::TimeResult where
    B: for<'a> Buffer<'a, S, T>, 

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

impl<T, D> From<DspVec<Vec<T, Global>, T, Complex, D>> for Vec<Complex<T>> where
    T: RealNumber,
    D: Domain, 

fn from(vector: DspVec<Vec<T>, T, Complex, D>) -> Self

Performs the conversion.

impl<T, D> From<DspVec<Vec<T, Global>, T, Real, D>> for Vec<T> where
    T: RealNumber,
    D: Domain, 

fn from(vector: DspVec<Vec<T>, T, Real, D>) -> Self

Performs the conversion.

impl<S, T, D> FromVector<T> for DspVec<S, T, Real, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = S

Type of the underlying storage of a vector.

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

If you are working with std::vec::Vec then it’s recommended to use
Into instead of this one, as it’s more straightforward to use.

impl<'a, T, D> FromVector<T> for DspVec<&'a [T], T, Complex, D> where
    T: RealNumber,
    D: Domain, 

type Output = &'a [Complex<T>]

Type of the underlying storage of a vector.

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

If you are working with std::vec::Vec then it’s recommended to use
Into instead of this one, as it’s more straightforward to use.

impl<'a, T, D> FromVector<T> for DspVec<&'a mut [T], T, Complex, D> where
    T: RealNumber,
    D: Domain, 

type Output = &'a mut [Complex<T>]

Type of the underlying storage of a vector.

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

If you are working with std::vec::Vec then it’s recommended to use
Into instead of this one, as it’s more straightforward to use.

impl<T, D> FromVector<T> for DspVec<Vec<T>, T, Complex, D> where
    T: RealNumber,
    D: Domain, 

type Output = Vec<Complex<T>>

Type of the underlying storage of a vector.

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

If you are working with std::vec::Vec then it’s recommended to use
Into instead of this one, as it’s more straightforward to use.

impl<S, T, N, D> FromVectorFloat<T> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

type Output = S

Type of the underlying storage of a vector.

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

Gets the underlying storage and the number of elements which contain valid data. In case of complex vectors the values are returned real-imag pairs. Refer to Into or FromVector for a method which returns the data of complex vectors in a different manner.

impl<S, T, N, D> GetMetaData<T, N, D> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    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, T, D> Index<Range<usize>> for DspVec<S, T, RealSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [T]

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &[T]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<Range<usize>> for DspVec<S, T, ComplexSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [Complex<T>]

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &[Complex<T>]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<RangeFrom<usize>> for DspVec<S, T, RealSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &[T]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<RangeFrom<usize>> for DspVec<S, T, ComplexSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [Complex<T>]

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &[Complex<T>]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<RangeFull> for DspVec<S, T, RealSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeFull) -> &[T]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<RangeFull> for DspVec<S, T, ComplexSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [Complex<T>]

The returned type after indexing.

fn index(&self, index: RangeFull) -> &[Complex<T>]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<RangeTo<usize>> for DspVec<S, T, RealSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &[T]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<RangeTo<usize>> for DspVec<S, T, ComplexSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = [Complex<T>]

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &[Complex<T>]

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<usize> for DspVec<S, T, RealSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &T

Performs the indexing (container[index]) operation.

impl<S, T, D> Index<usize> for DspVec<S, T, ComplexSpace, D> where
    S: ToSlice<T>,
    T: RealNumber,
    D: Domain, 

type Output = Complex<T>

The returned type after indexing.

fn index(&self, index: usize) -> &Complex<T>

Performs the indexing (container[index]) operation.

impl<S, T, D> IndexMut<Range<usize>> for DspVec<S, T, RealSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: Range<usize>) -> &mut [T]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<Range<usize>> for DspVec<S, T, ComplexSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: Range<usize>) -> &mut [Complex<T>]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<RangeFrom<usize>> for DspVec<S, T, RealSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [T]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<RangeFrom<usize>> for DspVec<S, T, ComplexSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [Complex<T>]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<RangeFull> for DspVec<S, T, RealSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: RangeFull) -> &mut [T]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<RangeFull> for DspVec<S, T, ComplexSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: RangeFull) -> &mut [Complex<T>]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<RangeTo<usize>> for DspVec<S, T, RealSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [T]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<RangeTo<usize>> for DspVec<S, T, ComplexSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [Complex<T>]

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<usize> for DspVec<S, T, RealSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<S, T, D> IndexMut<usize> for DspVec<S, T, ComplexSpace, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    D: Domain, 

fn index_mut(&mut self, index: usize) -> &mut Complex<T>

Performs the mutable indexing (container[index]) operation.

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

fn zero_pad(&mut self, points: usize, option: PaddingOption) -> VoidResult

Appends zeros add the end of the vector until the vector has the size given in the points argument. If points smaller than the self.len() then this operation won’t do anything, however in future it will raise an error.

fn zero_interleave(&mut self, factor: u32) -> VoidResult

Interleaves zeros factor - 1times after every vector element, so that the resulting vector will have a length of self.len() * factor.

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

fn zero_pad_b<B>(
    &mut self,
    buffer: &mut B,
    points: usize,
    option: PaddingOption
) -> VoidResult where
    B: for<'a> Buffer<'a, S, T>, 

Appends zeros add the end of the vector until the vector has the size given in the points argument. If points smaller than the self.len() then this operation will return an error.

fn zero_interleave_b<B>(&mut self, buffer: &mut B, factor: u32) where
    B: for<'a> Buffer<'a, S, T>, 

Interleaves zeros factor - 1times after every vector element, so that the resulting vector will have a length of self.len() * factor.

impl<S, T, N, D> InterpolationOps<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: InsertZerosOpsBuffered<S, T> + ScaleOps<T> + ResizeBufferedOps<S, T>,
    S: ToSliceMut<T> + ToComplexVector<S, T> + ToDspVector<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn interpolatef<B>(
    &mut self,
    buffer: &mut B,
    function: &dyn RealImpulseResponse<T>,
    interpolation_factor: T,
    delay: T,
    conv_len: usize
) where
    B: for<'a> Buffer<'a, 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<'a> Buffer<'a, S, T>, 

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

fn interpft<B>(&mut self, buffer: &mut B, dest_points: usize) where
    B: for<'a> Buffer<'a, 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 interpolate<B>(
    &mut self,
    buffer: &mut B,
    function: Option<&dyn RealFrequencyResponse<T>>,
    dest_points: usize,
    delay: T
) -> VoidResult where
    B: for<'a> Buffer<'a, S, T>, 

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

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

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

impl<S, T, N, D, R> MapAggregateOps<Complex<T>, R> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain,
    R: Send, 

type Output = ScalarResult<R>

fn map_aggregate<'a, A, FMap, FAggr>(
    &self,
    argument: A,
    map: &FMap,
    aggregate: &FAggr
) -> ScalarResult<R> where
    A: Sync + Copy + Send,
    FMap: Fn(Complex<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, T, N, D, R> MapAggregateOps<T, R> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain,
    R: Send, 

type Output = ScalarResult<R>

fn map_aggregate<'a, A, FMap, FAggr>(
    &self,
    argument: A,
    map: &FMap,
    aggregate: &FAggr
) -> ScalarResult<R> where
    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, T, N, D> MapInplaceOps<Complex<T>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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, T, N, D> MapInplaceOps<T> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

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, T, N, D> MergeOps for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn merge(&mut self, sources: &[&Self]) -> VoidResult

Merges several vectors into self. All vectors must have the same size and at least one vector must be provided.

impl<S, T, N, D> MetaData for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

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, T, N, D> ModuloOps<T> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

fn wrap(&mut self, divisor: T)

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

fn unwrap(&mut self, divisor: T)

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

impl<S, T, N, D> OffsetOps<Complex<T>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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

Adds a scalar to each vector element.

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

fn offset(&mut self, offset: T)

Adds a scalar to each vector element.

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

fn sqrt(&mut self)

Gets the square root of all vector elements.

fn square(&mut self)

Squares all vector elements.

fn root(&mut self, degree: T)

Calculates the n-th root of every vector element.

fn powf(&mut self, exponent: T)

Raises every vector element to a floating point power.

fn ln(&mut self)

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

fn exp(&mut self)

Calculates the natural exponential for every vector element.

fn log(&mut self, base: T)

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

fn expf(&mut self, base: T)

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

impl<S, O, T, N, D, NO, DO> PreciseDotProductOps<O, Complex<T>, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain,
    O: Vector<T> + GetMetaData<T, NO, DO>,
    NO: PosEq<N> + NumberSpace,
    DO: PosEq<D> + Domain, 

type Output = ScalarResult<Complex<T>>

fn dot_product_prec(&self, factor: &O) -> ScalarResult<Complex<T>>

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

impl<S, O, T, N, D, NO, DO> PreciseDotProductOps<O, T, T, NO, DO> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain,
    O: Vector<T> + GetMetaData<T, NO, DO>,
    NO: PosEq<N> + NumberSpace,
    DO: PosEq<D> + Domain, 

type Output = ScalarResult<T>

fn dot_product_prec(&self, factor: &O) -> ScalarResult<T>

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

impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f32, N, D> where
    S: ToSlice<f32>,
    N: ComplexNumberSpace,
    D: Domain, 

type Result = Statistics<Complex<f64>>

fn statistics_prec(&self) -> Statistics<Complex<f64>>

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

impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f64, N, D> where
    S: ToSlice<f64>,
    N: ComplexNumberSpace,
    D: Domain, 

type Result = Statistics<Complex<f64>>

fn statistics_prec(&self) -> Statistics<Complex<f64>>

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

impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f32, N, D> where
    S: ToSlice<f32>,
    N: RealNumberSpace,
    D: Domain, 

type Result = Statistics<f64>

fn statistics_prec(&self) -> Statistics<f64>

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

impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f64, N, D> where
    S: ToSlice<f64>,
    N: RealNumberSpace,
    D: Domain, 

type Result = Statistics<f64>

fn statistics_prec(&self) -> Statistics<f64>

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

impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f32, N, D> where
    S: ToSlice<f32>,
    N: ComplexNumberSpace,
    D: Domain, 

type Result = StatsVec<Statistics<Complex<f64>>>

fn statistics_split_prec(
    &self,
    len: usize
) -> ScalarResult<StatsVec<Statistics<Complex<f64>>>>

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, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f64, N, D> where
    S: ToSlice<f64>,
    N: ComplexNumberSpace,
    D: Domain, 

type Result = StatsVec<Statistics<Complex<f64>>>

fn statistics_split_prec(
    &self,
    len: usize
) -> ScalarResult<StatsVec<Statistics<Complex<f64>>>>

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, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f32, N, D> where
    S: ToSlice<f32>,
    N: RealNumberSpace,
    D: Domain, 

type Result = StatsVec<Statistics<f64>>

fn statistics_split_prec(
    &self,
    len: usize
) -> ScalarResult<StatsVec<Statistics<f64>>>

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, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f64, N, D> where
    S: ToSlice<f64>,
    N: RealNumberSpace,
    D: Domain, 

type Result = StatsVec<Statistics<f64>>

fn statistics_split_prec(
    &self,
    len: usize
) -> ScalarResult<StatsVec<Statistics<f64>>>

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, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f32, N, D> where
    S: ToSlice<f32>,
    N: ComplexNumberSpace,
    D: Domain, 

fn sum_prec(&self) -> Complex<f64>

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

fn sum_sq_prec(&self) -> Complex<f64>

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

impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f64, N, D> where
    S: ToSlice<f64>,
    N: ComplexNumberSpace,
    D: Domain, 

fn sum_prec(&self) -> Complex<f64>

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

fn sum_sq_prec(&self) -> Complex<f64>

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

impl<S, N, D> PreciseSumOps<f64> for DspVec<S, f32, N, D> where
    S: ToSlice<f32>,
    N: RealNumberSpace,
    D: Domain, 

fn sum_prec(&self) -> f64

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

fn sum_sq_prec(&self) -> f64

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

impl<S, N, D> PreciseSumOps<f64> for DspVec<S, f64, N, D> where
    S: ToSlice<f64>,
    N: RealNumberSpace,
    D: Domain, 

fn sum_prec(&self) -> f64

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

fn sum_sq_prec(&self) -> f64

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

impl<S, T, N, D> RealInterpolationOps<S, T> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

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

Linear interpolation between samples.

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

Piecewise cubic hermite interpolation between samples.

impl<S, T, N, D> RealOps for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

fn abs(&mut self)

Gets the absolute value of all vector elements.

impl<S, T, N, D> RealToComplexTransformsOps<T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToComplexResult + InsertZerosOps<T>,
    <DspVec<S, T, N, D> as ToComplexResult>::ComplexResult: RededicateForceOps<DspVec<S, T, N, D>>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

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

Converts the real vector into a complex vector.

impl<S, T, N, D> RealToComplexTransformsOpsBuffered<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToComplexResult + InsertZerosOpsBuffered<S, T>,
    <DspVec<S, T, N, D> as ToComplexResult>::ComplexResult: RededicateForceOps<DspVec<S, T, N, D>>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

fn to_complex_b<B>(self, buffer: &mut B) -> Self::ComplexResult where
    B: for<'a> Buffer<'a, S, T>, 

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

impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for RealTimeVec<S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self

Make Other a Self without performing any checks.

fn rededicate_with_runtime_data(
    origin: DspVec<S, T, N, D>,
    _: bool,
    _: DataDomain
) -> Self

Make Other a Self without performing any checks.

impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for RealFreqVec<S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self

Make Other a Self without performing any checks.

fn rededicate_with_runtime_data(
    origin: DspVec<S, T, N, D>,
    _: bool,
    _: DataDomain
) -> Self

Make Other a Self without performing any checks.

impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for ComplexTimeVec<S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self

Make Other a Self without performing any checks.

fn rededicate_with_runtime_data(
    origin: DspVec<S, T, N, D>,
    _: bool,
    _: DataDomain
) -> Self

Make Other a Self without performing any checks.

impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for ComplexFreqVec<S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self

Make Other a Self without performing any checks.

fn rededicate_with_runtime_data(
    origin: DspVec<S, T, N, D>,
    _: bool,
    _: DataDomain
) -> Self

Make Other a Self without performing any checks.

impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for GenDspVec<S, T> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self

Make Other a Self without performing any checks.

fn rededicate_with_runtime_data(
    origin: DspVec<S, T, N, D>,
    is_complex: bool,
    domain: DataDomain
) -> Self

Make Other a Self without performing any checks.

impl<S, T, N, D, O> RededicateOps<O> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    DspVec<S, T, N, D>: RededicateForceOps<O>,
    N: NumberSpace,
    D: Domain,
    O: Vector<T>, 

fn rededicate_from(origin: O) -> Self

Make Other a Self.

impl<S, T, N, D, O> RededicateToOps<O> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain,
    O: Vector<T> + RededicateOps<Self>, 

fn rededicate(self) -> O

Converts Self inot Other.

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

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, T, N, D> ResizeBufferedOps<S, T> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn resize_b<B>(&mut self, buffer: &mut B, len: usize) -> VoidResult where
    B: for<'a> Buffer<'a, S, T>, 

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 or the buffer supports resizing.

impl<S, T, N, D> ResizeOps for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

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<S, T, D, N> ScaleOps<Complex<T>> for DspVec<S, T, N, D> where
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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

Multiplies the vector element with a scalar.

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

fn scale(&mut self, factor: T)

Multiplies the vector element with a scalar.

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

fn split_into(&self, targets: &mut [&mut Self]) -> VoidResult

Splits the vector into several smaller vectors. self.len() must be dividable by targets.len() without a remainder and this condition must be true too targets.len() > 0.

impl<S, T, N, D> StatisticsOps<Complex<T>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Result = Statistics<Complex<T>>

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

Calculates the statistics of the data.

impl<S, T, N, D> StatisticsOps<T> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

type Result = Statistics<T>

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

Calculates the statistics of the data.

impl<S, T, N, D> StatisticsSplitOps<Complex<T>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

type Result = StatsVec<Statistics<Complex<T>>>

fn statistics_split(
    &self,
    len: usize
) -> ScalarResult<StatsVec<Statistics<Complex<T>>>>

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, T, N, D> StatisticsSplitOps<T> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

type Result = StatsVec<Statistics<T>>

fn statistics_split(&self, len: usize) -> ScalarResult<StatsVec<Statistics<T>>>

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, T, N, D> SumOps<Complex<T>> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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

Calculates the sum of the data contained in the vector.

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

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

impl<S, T, N, D> SumOps<T> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

fn sum(&self) -> T

Calculates the sum of the data contained in the vector.

fn sum_sq(&self) -> T

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

impl<S, T, N, D> SymmetricFrequencyToTimeDomainOperations<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToRealTimeResult + ToTimeResult + FrequencyDomainOperations<S, T>,
    <DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult: RededicateForceOps<DspVec<S, T, N, D>> + TimeDomainOperations<S, T>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: FrequencyDomain, 

fn plain_sifft<B>(self, buffer: &mut B) -> TransRes<Self::RealTimeResult> where
    B: for<'a> Buffer<'a, 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<'a> Buffer<'a, 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<'a> Buffer<'a, 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, T, N, D> SymmetricTimeToFrequencyDomainOperations<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToFreqResult,
    <DspVec<S, T, N, D> as ToFreqResult>::FreqResult: RededicateForceOps<DspVec<S, T, N, D>> + FrequencyDomainOperations<S, T> + ResizeOps,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: RealNumberSpace,
    D: TimeDomain, 

fn plain_sfft<B>(self, buffer: &mut B) -> TransRes<Self::FreqResult> where
    B: for<'a> Buffer<'a, 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<'a> Buffer<'a, 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 windowed_sfft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> TransRes<Self::FreqResult> where
    B: for<'a> Buffer<'a, 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<S, T, N, D> TimeDomainOperations<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToFreqResult,
    <DspVec<S, T, N, D> as ToFreqResult>::FreqResult: RededicateForceOps<DspVec<S, T, N, D>>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: TimeDomain, 

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, T, N, D> TimeToFrequencyDomainOperations<S, T> for DspVec<S, T, N, D> where
    DspVec<S, T, N, D>: ToFreqResult,
    <DspVec<S, T, N, D> as ToFreqResult>::FreqResult: RededicateForceOps<DspVec<S, T, N, D>> + FrequencyDomainOperations<S, T>,
    S: ToSliceMut<T>,
    T: RealNumber,
    N: NumberSpace,
    D: TimeDomain, 

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

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

fn windowed_fft<B>(
    self,
    buffer: &mut B,
    window: &dyn WindowFunction<T>
) -> Self::FreqResult where
    B: for<'a> Buffer<'a, S, T>, 

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

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

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<S, T, N, D> Vector<T> for DspVec<S, T, N, D> where
    S: ToSlice<T>,
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

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 len(&self) -> usize

The number of valid elements in the vector. This can be changed with the Resize trait.

fn is_empty(&self) -> bool

Indicates whether or not the vector is empty.

fn points(&self) -> usize

The number of valid points. If the vector 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 get_multicore_settings(&self) -> &MultiCoreSettings

Gets the multi core settings which determine how the work is split between several cores if the amount of data gets larger.

fn set_multicore_settings(&mut self, settings: MultiCoreSettings)

Sets the multi core settings which determine how the work is split between several cores if the amount of data gets larger.

fn alloc_len(&self) -> usize

Gets the number of allocated elements in the underlying vector. The allocated length may be larger than the length of valid points. In most cases you likely want to have lenor points instead.