Struct basic_dsp::RealFreqVector [−] [src]

pub struct RealFreqVector<T> where T: RealNumber {
    // some fields omitted
}

A 1xN (one times N elements) or Nx1 data vector as used for most digital signal processing (DSP) operations. All data vector operations consume the vector they operate on and return a new vector. A consumed vector must not be accessed again.

Vectors come in different flavors:

Time or Frequency domain
Real or Complex numbers
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 DataVector32 and DataVector64 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.

Methods

`impl<T> RealFreqVector<T> where T: RealNumber`
[src]

`fn from_array_no_copy_with_options(data: Vec<T>, options: MultiCoreSettings) -> Self`

Same as from_array_no_copy but also allows to set multicore options.

`fn from_array_with_options(data: &[T], options: MultiCoreSettings) -> Self`

Same as from_array but also allows to set multicore options.

`fn from_array_with_delta_and_options(data: &[T], delta: T, options: MultiCoreSettings) -> Self`

Same as from_array_with_delta but also allows to set multicore options.

`fn empty_with_options(options: MultiCoreSettings) -> Self`

Same as empty but also allows to set multicore options.

`fn empty_with_delta_and_options(delta: T, options: MultiCoreSettings) -> Self`

Same as empty_with_delta but also allows to set multicore options.

`fn from_constant_with_options(constant: T, length: usize, options: MultiCoreSettings) -> Self`

Same as from_constant but also allows to set multicore options.

`fn from_constant_with_delta_and_options(constant: T, length: usize, delta: T, options: MultiCoreSettings) -> Self`

Same as from_constant_with_delta but also allows to set multicore options.

`fn from_array_no_copy(data: Vec<T>) -> Self`

Creates a real DataVector by consuming a Vec.

This operation is more memory efficient than the other options to create a vector, however if used outside of Rust then it holds the risk that the user will access the data parameter after the vector has been created causing all types of issues.

`fn from_array(data: &[T]) -> Self`

Creates a real DataVector from an array or sequence. delta is defaulted to 1.

`fn from_array_with_delta(data: &[T], delta: T) -> Self`

Creates a real DataVector from an array or sequence and sets delta to the given value.

`fn empty() -> Self`

Creates a real and empty DataVector and sets delta to 1.0 value.

`fn empty_with_delta(delta: T) -> Self`

Creates a real and empty DataVector and sets delta to the given value.

`fn from_constant(constant: T, length: usize) -> Self`

Creates a real DataVector with length elements all set to the value of constant. delta is defaulted to 1.

`fn from_constant_with_delta(constant: T, length: usize, delta: T) -> Self`

Creates a real DataVector with length elements all set to the value of constant and sets delta to the given value.

Trait Implementations

`impl<'a> FrequencyMultiplication<f32, &'a RealFrequencyResponse<f32>> for RealFreqVector<f32>`
[src]

`fn multiply_frequency_response(self, function: &RealFrequencyResponse<f32>, ratio: f32) -> VecResult<Self>`

Mutiplies self with the frequency response function frequency_response. Read more

`impl<'a> FrequencyMultiplication<f64, &'a RealFrequencyResponse<f64>> for RealFreqVector<f64>`
[src]

`fn multiply_frequency_response(self, function: &RealFrequencyResponse<f64>, ratio: f64) -> VecResult<Self>`

Mutiplies self with the frequency response function frequency_response. Read more

`impl VectorConvolution<f32> for RealFreqVector<f32>`
[src]

`fn convolve_vector(self, other: &Self) -> VecResult<Self>`

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. # Failures VecResult may report the following ErrorReason members: Read more

`impl VectorConvolution<f64> for RealFreqVector<f64>`
[src]

`fn convolve_vector(self, other: &Self) -> VecResult<Self>`

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. # Failures VecResult may report the following ErrorReason members: Read more

`impl Interpolation<f32> for RealFreqVector<f32>`
[src]

`fn interpolatef(self, function: &RealImpulseResponse<f32>, interpolation_factor: f32, delay: f32, len: usize) -> VecResult<Self>`

Interpolates self with the convolution function function by the real value interpolation_factor. Interpolation is done in 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(). Read more

`fn interpolatei(self, function: &RealFrequencyResponse<f32>, interpolation_factor: u32) -> VecResult<Self>`

Interpolates self with the convolution function function by the interger value interpolation_factor. Interpolation is done in in frequency domain. Read more

`fn decimatei(self, decimation_factor: u32, delay: u32) -> VecResult<Self>`

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

`impl Interpolation<f64> for RealFreqVector<f64>`
[src]

`fn interpolatef(self, function: &RealImpulseResponse<f64>, interpolation_factor: f64, delay: f64, len: usize) -> VecResult<Self>`

Interpolates self with the convolution function function by the real value interpolation_factor. Interpolation is done in 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(). Read more

`fn interpolatei(self, function: &RealFrequencyResponse<f64>, interpolation_factor: u32) -> VecResult<Self>`

Interpolates self with the convolution function function by the interger value interpolation_factor. Interpolation is done in in frequency domain. Read more

`fn decimatei(self, decimation_factor: u32, delay: u32) -> VecResult<Self>`

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

`impl RealInterpolation<f32> for RealFreqVector<f32>`
[src]

`fn interpolate_lin(self, interpolation_factor: f32, delay: f32) -> VecResult<Self>`

Linear interpolation between samples. # Unstable This operation and interpolate_hermite might be merged into one function with an additional argument in future. Read more

`fn interpolate_hermite(self, interpolation_factor: f32, delay: f32) -> VecResult<Self>`

Piecewise cubic hermite interpolation between samples. # Unstable Algorithm might need to be revised. This operation and interpolate_lin might be merged into one function with an additional argument in future. Read more

`impl RealInterpolation<f64> for RealFreqVector<f64>`
[src]

`fn interpolate_lin(self, interpolation_factor: f64, delay: f64) -> VecResult<Self>`

Linear interpolation between samples. # Unstable This operation and interpolate_hermite might be merged into one function with an additional argument in future. Read more

`fn interpolate_hermite(self, interpolation_factor: f64, delay: f64) -> VecResult<Self>`

Piecewise cubic hermite interpolation between samples. # Unstable Algorithm might need to be revised. This operation and interpolate_lin might be merged into one function with an additional argument in future. Read more

`impl<T: Debug> Debug for RealFreqVector<T> where T: RealNumber`
[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`

Formats the value using the given formatter.

`impl<T> DataVector<T> for RealFreqVector<T> where T: RealNumber`
[src]

`fn len(&self) -> usize`

The number of valid elements in the the vector.

`fn set_len(&mut self, len: usize)`

Sets the vector length to the given length. If self.len() < len then the value of the new elements is undefined. Read more

`fn allocated_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. Read more

`fn data(&self) -> &[T]`

Gives direct access to the underlying data sequence. It's recommended to use the `Index functions . For users outside of Rust: It's discouraged to hold references to this array while executing operations on the vector, since the vector may decide at any operation to invalidate the array. Read more

`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 domain(&self) -> DataVectorDomain`

The domain in which the data vector resides. Basically specifies the x-axis and the type of operations which are valid on this vector. Read more

`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. Read more

`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. Read more

`impl<T> RededicateVector<T> for RealFreqVector<T> where T: RealNumber`
[src]

`fn rededicate_as_complex_time_vector(self, delta: T) -> ComplexTimeVector<T>`

Make self a complex time vector # Example Read more

`fn rededicate_as_complex_freq_vector(self, delta: T) -> ComplexFreqVector<T>`

Make self a complex frequency vector

`fn rededicate_as_real_time_vector(self, delta: T) -> RealTimeVector<T>`

Make self a real time vector

`fn rededicate_as_real_freq_vector(self, delta: T) -> RealFreqVector<T>`

Make self a real freq vector

`fn rededicate_as_generic_vector(self, is_complex: bool, domain: DataVectorDomain, delta: T) -> GenericDataVector<T>`

Make self a generic vector