Struct basic_dsp_vector::DspVec [−][src]
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:
- 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 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.
Methods
impl<S, T, N, D> DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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
.
Trait Implementations
impl<S, T, N, D> FromVector<T> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> FromVector<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 get(self) -> (Self::Output, usize)
[src]
fn get(self) -> (Self::Output, usize)
Gets the underlying storage and the number of elements which contain valid. Read more
fn to_slice(&self) -> &[T]
[src]
fn to_slice(&self) -> &[T]
Gets the underlying slice of a vector.
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,
[src]
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
[src]
fn clone(&self) -> Self
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<S, T, N, D> MetaData for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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. Read more
fn is_complex(&self) -> bool
[src]
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
impl<S, T, N, D> ResizeOps for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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. Read more
impl<S, T, N, D> ResizeBufferedOps<S, T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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>,
[src]
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. Read more
impl<S, T, N, D> Vector<T> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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]
. Read more
fn set_delta(&mut self, delta: T)
[src]
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]
. Read more
fn len(&self) -> usize
[src]
fn len(&self) -> usize
The number of valid elements in the vector. This can be changed with the Resize
trait. Read more
fn is_empty(&self) -> bool
[src]
fn is_empty(&self) -> bool
Indicates whether or not the vector is empty.
fn points(&self) -> usize
[src]
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
fn get_multicore_settings(&self) -> &MultiCoreSettings
[src]
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. Read more
fn set_multicore_settings(&mut self, settings: MultiCoreSettings)
[src]
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. Read more
fn alloc_len(&self) -> usize
[src]
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 len
or points
instead. Read more
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,
[src]
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>
[src]
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. Read more
impl<S, T, N, D> Index<usize> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> Index<usize> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
type Output = T
The returned type after indexing.
ⓘImportant traits for &'a mut Rfn index(&self, index: usize) -> &T
[src]
fn index(&self, index: usize) -> &T
Performs the indexing (container[index]
) operation.
impl<S, T, N, D> IndexMut<usize> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> IndexMut<usize> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
ⓘImportant traits for &'a mut Rfn index_mut(&mut self, index: usize) -> &mut T
[src]
fn index_mut(&mut self, index: usize) -> &mut T
Performs the mutable indexing (container[index]
) operation.
impl<S, T, N, D> Index<RangeFull> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> Index<RangeFull> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
type Output = [T]
The returned type after indexing.
fn index(&self, _index: RangeFull) -> &[T]
[src]
fn index(&self, _index: RangeFull) -> &[T]
Performs the indexing (container[index]
) operation.
impl<S, T, N, D> IndexMut<RangeFull> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> IndexMut<RangeFull> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
fn index_mut(&mut self, _index: RangeFull) -> &mut [T]
[src]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T]
Performs the mutable indexing (container[index]
) operation.
impl<S, T, N, D> Index<RangeFrom<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> Index<RangeFrom<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
type Output = [T]
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &[T]
[src]
fn index(&self, index: RangeFrom<usize>) -> &[T]
Performs the indexing (container[index]
) operation.
impl<S, T, N, D> IndexMut<RangeFrom<usize>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> IndexMut<RangeFrom<usize>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [T]
[src]
fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut [T]
Performs the mutable indexing (container[index]
) operation.
impl<S, T, N, D> Index<RangeTo<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> Index<RangeTo<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
type Output = [T]
The returned type after indexing.
fn index(&self, index: RangeTo<usize>) -> &[T]
[src]
fn index(&self, index: RangeTo<usize>) -> &[T]
Performs the indexing (container[index]
) operation.
impl<S, T, N, D> IndexMut<RangeTo<usize>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> IndexMut<RangeTo<usize>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [T]
[src]
fn index_mut(&mut self, index: RangeTo<usize>) -> &mut [T]
Performs the mutable indexing (container[index]
) operation.
impl<S, T, N, D> Index<Range<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> Index<Range<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
type Output = [T]
The returned type after indexing.
fn index(&self, index: Range<usize>) -> &[T]
[src]
fn index(&self, index: Range<usize>) -> &[T]
Performs the indexing (container[index]
) operation.
impl<S, T, N, D> IndexMut<Range<usize>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> IndexMut<Range<usize>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
fn index_mut(&mut self, index: Range<usize>) -> &mut [T]
[src]
fn index_mut(&mut self, index: Range<usize>) -> &mut [T]
Performs the mutable indexing (container[index]
) operation.
impl<S, T, N, D> ComplexIndex<usize> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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 complex(&self, index: usize) -> &Complex<T>
[src]
fn complex(&self, index: usize) -> &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,
[src]
impl<S, T, N, D> ComplexIndexMut<usize> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
fn complex_mut(&mut self, index: usize) -> &mut Complex<T>
[src]
fn complex_mut(&mut self, index: usize) -> &mut 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,
[src]
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 complex(&self, _index: RangeFull) -> &[Complex<T>]
[src]
fn complex(&self, _index: RangeFull) -> &[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,
[src]
impl<S, T, N, D> ComplexIndexMut<RangeFull> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
fn complex_mut(&mut self, _index: RangeFull) -> &mut [Complex<T>]
[src]
fn complex_mut(&mut self, _index: RangeFull) -> &mut [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,
[src]
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 complex(&self, index: RangeFrom<usize>) -> &[Complex<T>]
[src]
fn complex(&self, index: RangeFrom<usize>) -> &[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,
[src]
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 complex_mut(&mut self, index: RangeFrom<usize>) -> &mut [Complex<T>]
[src]
fn complex_mut(&mut self, index: RangeFrom<usize>) -> &mut [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,
[src]
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 complex(&self, index: RangeTo<usize>) -> &[Complex<T>]
[src]
fn complex(&self, index: RangeTo<usize>) -> &[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,
[src]
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 complex_mut(&mut self, index: RangeTo<usize>) -> &mut [Complex<T>]
[src]
fn complex_mut(&mut self, index: RangeTo<usize>) -> &mut [Complex<T>]
The method for complex indexing
impl<S, T, N, D> ComplexIndex<Range<usize>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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 complex(&self, index: Range<usize>) -> &[Complex<T>]
[src]
fn complex(&self, index: Range<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,
[src]
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 complex_mut(&mut self, index: Range<usize>) -> &mut [Complex<T>]
[src]
fn complex_mut(&mut self, index: Range<usize>) -> &mut [Complex<T>]
The method for complex indexing
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,
[src]
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
[src]
fn magnitude(self) -> Self::RealResult
Gets the absolute value, magnitude or norm of all vector elements. # Example Read more
fn magnitude_squared(self) -> Self::RealResult
[src]
fn magnitude_squared(self) -> Self::RealResult
Gets the square root of the absolute value of all vector elements. # Example Read more
fn to_real(self) -> Self::RealResult
[src]
fn to_real(self) -> Self::RealResult
Gets all real elements. # Example Read more
fn to_imag(self) -> Self::RealResult
[src]
fn to_imag(self) -> Self::RealResult
Gets all imag elements. # Example Read more
fn phase(self) -> Self::RealResult
[src]
fn phase(self) -> Self::RealResult
Gets the phase of all elements in [rad]. # Example Read more
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,
[src]
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>,
[src]
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. # Example Read more
fn magnitude_squared_b<B>(self, buffer: &mut B) -> Self::RealResult where
B: for<'a> Buffer<'a, S, T>,
[src]
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. # Example Read more
fn to_real_b<B>(self, buffer: &mut B) -> Self::RealResult where
B: for<'a> Buffer<'a, S, T>,
[src]
fn to_real_b<B>(self, buffer: &mut B) -> Self::RealResult where
B: for<'a> Buffer<'a, S, T>,
Gets all real elements. # Example Read more
fn to_imag_b<B>(self, buffer: &mut B) -> Self::RealResult where
B: for<'a> Buffer<'a, S, T>,
[src]
fn to_imag_b<B>(self, buffer: &mut B) -> Self::RealResult where
B: for<'a> Buffer<'a, S, T>,
Gets all imag elements. # Example Read more
fn phase_b<B>(self, buffer: &mut B) -> Self::RealResult where
B: for<'a> Buffer<'a, S, T>,
[src]
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]. # Example Read more
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> + Index<Range<usize>, Output = [T]> + IndexMut<Range<usize>>,
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
NR: RealNumberSpace,
D: Domain,
DO: PosEq<D> + Domain,
[src]
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> + Index<Range<usize>, Output = [T]> + IndexMut<Range<usize>>,
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
NR: RealNumberSpace,
D: Domain,
DO: PosEq<D> + Domain,
fn get_real(&self, destination: &mut O)
[src]
fn get_real(&self, destination: &mut O)
Copies all real elements into the given vector. # Example Read more
fn get_imag(&self, destination: &mut O)
[src]
fn get_imag(&self, destination: &mut O)
Copies all imag elements into the given vector. # Example Read more
fn get_magnitude(&self, destination: &mut O)
[src]
fn get_magnitude(&self, destination: &mut O)
Copies the absolute value or magnitude of all vector elements into the given target vector. # Example Read more
fn get_magnitude_squared(&self, destination: &mut O)
[src]
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 Read more
fn get_phase(&self, destination: &mut O)
[src]
fn get_phase(&self, destination: &mut O)
Copies the phase of all elements in [rad] into the given vector. # Example Read more
fn get_real_imag(&self, real: &mut O, imag: &mut O)
[src]
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. Read more
fn get_mag_phase(&self, mag: &mut O, phase: &mut O)
[src]
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. Read more
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: Index<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,
[src]
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: Index<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
[src]
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. Read more
fn set_mag_phase(&mut self, mag: &O, phase: &O) -> VoidResult
[src]
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. Read more
impl<S, T, N, D> ComplexOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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)
[src]
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. Read more
fn conj(&mut self)
[src]
fn conj(&mut self)
Calculates the complex conjugate of the vector. # Example Read more
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,
[src]
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>
[src]
fn to_complex(self) -> TransRes<Self::ComplexResult>
Converts the real vector into a complex vector. Read more
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,
[src]
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>,
[src]
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. Read more
impl<S, T, N, D> RealOps for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
impl<S, T, N, D> RealOps for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
impl<S, T, N, D> ModuloOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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)
[src]
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. Read more
fn unwrap(&mut self, divisor: T)
[src]
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. Read more
impl<S, T, N, D> ApproximatedOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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)
[src]
fn ln_approx(&mut self)
Computes the principal value approximation of natural logarithm of every element in the vector. Read more
fn exp_approx(&mut self)
[src]
fn exp_approx(&mut self)
Calculates the natural exponential approximation for every vector element. Read more
fn sin_approx(&mut self)
[src]
fn sin_approx(&mut self)
Calculates the sine approximation of each element in radians. Read more
fn cos_approx(&mut self)
[src]
fn cos_approx(&mut self)
Calculates the cosine approximation of each element in radians Read more
fn log_approx(&mut self, base: T)
[src]
fn log_approx(&mut self, base: T)
Calculates the approximated logarithm to the given base for every vector element. Read more
fn expf_approx(&mut self, base: T)
[src]
fn expf_approx(&mut self, base: T)
Calculates the approximated exponential to the given base for every vector element. Read more
fn powf_approx(&mut self, exponent: T)
[src]
fn powf_approx(&mut self, exponent: T)
Raises every vector element to approximately a floating point power. Read more
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,
[src]
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>,
[src]
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). Read more
fn fft_shift(&mut self)
[src]
fn fft_shift(&mut self)
Swaps vector halves after a Fourier Transformation.
fn ifft_shift(&mut self)
[src]
fn ifft_shift(&mut self)
Swaps vector halves before an Inverse Fourier Transformation.
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,
[src]
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: &WindowFunction<T>)
[src]
fn apply_window(&mut self, window: &WindowFunction<T>)
Applies a window to the data vector.
fn unapply_window(&mut self, window: &WindowFunction<T>)
[src]
fn unapply_window(&mut self, window: &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,
[src]
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>,
[src]
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. Read more
fn fft<B>(self, buffer: &mut B) -> Self::FreqResult where
B: for<'a> Buffer<'a, S, T>,
[src]
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. # Unstable FFTs of real vectors are unstable. # Example Read more
fn windowed_fft<B>(
self,
buffer: &mut B,
window: &WindowFunction<T>
) -> Self::FreqResult where
B: for<'a> Buffer<'a, S, T>,
[src]
fn windowed_fft<B>(
self,
buffer: &mut B,
window: &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. Read more
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,
[src]
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>,
[src]
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. Read more
fn sfft<B>(self, buffer: &mut B) -> TransRes<Self::FreqResult> where
B: for<'a> Buffer<'a, S, T>,
[src]
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. # Failures TransRes may report the following ErrorReason
members: Read more
fn windowed_sfft<B>(
self,
buffer: &mut B,
window: &WindowFunction<T>
) -> TransRes<Self::FreqResult> where
B: for<'a> Buffer<'a, S, T>,
[src]
fn windowed_sfft<B>(
self,
buffer: &mut B,
window: &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. # Failures TransRes may report the following ErrorReason
members: Read more
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,
[src]
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>,
[src]
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. Read more
fn ifft<B>(self, buffer: &mut B) -> Self::TimeResult where
B: for<'a> Buffer<'a, S, T>,
[src]
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. # Example Read more
fn windowed_ifft<B>(
self,
buffer: &mut B,
window: &WindowFunction<T>
) -> Self::TimeResult where
B: for<'a> Buffer<'a, S, T>,
[src]
fn windowed_ifft<B>(
self,
buffer: &mut B,
window: &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. Read more
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,
[src]
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>,
[src]
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. Read more
fn sifft<B>(self, buffer: &mut B) -> TransRes<Self::RealTimeResult> where
B: for<'a> Buffer<'a, S, T>,
[src]
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. Read more
fn windowed_sifft<B>(
self,
buffer: &mut B,
window: &WindowFunction<T>
) -> TransRes<Self::RealTimeResult> where
B: for<'a> Buffer<'a, S, T>,
[src]
fn windowed_sifft<B>(
self,
buffer: &mut B,
window: &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. Read more
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,
[src]
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>,
[src]
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: Read more
fn prepare_argument_padded<B>(self, buffer: &mut B) -> Self::FreqResult where
B: for<'a> Buffer<'a, S, T>,
[src]
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
. Read more
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
[src]
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> VoidResult where
B: for<'a> Buffer<'a, S, T>,
[src]
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. Read more
impl<'a, S, T, N, D> Convolution<'a, S, T, &'a RealImpulseResponse<T>> 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>,
[src]
impl<'a, S, T, N, D> Convolution<'a, S, T, &'a RealImpulseResponse<T>> 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: &RealImpulseResponse<T>,
ratio: T,
len: usize
) where
B: for<'b> Buffer<'b, S, T>,
[src]
fn convolve<B>(
&mut self,
buffer: &mut B,
function: &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
. Read more
impl<'a, S, T, N, D> Convolution<'a, S, T, &'a ComplexImpulseResponse<T>> 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>,
[src]
impl<'a, S, T, N, D> Convolution<'a, S, T, &'a ComplexImpulseResponse<T>> 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: &ComplexImpulseResponse<T>,
ratio: T,
len: usize
) where
B: for<'b> Buffer<'b, S, T>,
[src]
fn convolve<B>(
&mut self,
buffer: &mut B,
function: &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
. Read more
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,
[src]
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>,
[src]
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. Read more
impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a ComplexFrequencyResponse<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: FrequencyDomain,
[src]
impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a ComplexFrequencyResponse<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: FrequencyDomain,
fn multiply_frequency_response(
&mut self,
frequency_response: &ComplexFrequencyResponse<T>,
ratio: T
)
[src]
fn multiply_frequency_response(
&mut self,
frequency_response: &ComplexFrequencyResponse<T>,
ratio: T
)
Multiplies self
with the frequency response function frequency_response
. Read more
impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a RealFrequencyResponse<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: FrequencyDomain,
[src]
impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a RealFrequencyResponse<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: FrequencyDomain,
fn multiply_frequency_response(
&mut self,
frequency_response: &RealFrequencyResponse<T>,
ratio: T
)
[src]
fn multiply_frequency_response(
&mut self,
frequency_response: &RealFrequencyResponse<T>,
ratio: T
)
Multiplies self
with the frequency response function frequency_response
. Read more
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,
[src]
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: &RealImpulseResponse<T>,
interpolation_factor: T,
delay: T,
conv_len: usize
) where
B: for<'a> Buffer<'a, S, T>,
[src]
fn interpolatef<B>(
&mut self,
buffer: &mut B,
function: &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()
. Read more
fn interpolatei<B>(
&mut self,
buffer: &mut B,
function: &RealFrequencyResponse<T>,
interpolation_factor: u32
) -> VoidResult where
B: for<'a> Buffer<'a, S, T>,
[src]
fn interpolatei<B>(
&mut self,
buffer: &mut B,
function: &RealFrequencyResponse<T>,
interpolation_factor: u32
) -> VoidResult where
B: for<'a> Buffer<'a, S, T>,
Interpolates self
with the convolution function function
by the interger value interpolation_factor
. InterpolationOps is done in in frequency domain. Read more
fn interpft<B>(&mut self, buffer: &mut B, dest_points: usize) where
B: for<'a> Buffer<'a, S, T>,
[src]
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. Read more
fn interpolate<B>(
&mut self,
buffer: &mut B,
function: Option<&RealFrequencyResponse<T>>,
dest_points: usize,
delay: T
) -> VoidResult where
B: for<'a> Buffer<'a, S, T>,
[src]
fn interpolate<B>(
&mut self,
buffer: &mut B,
function: Option<&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)
[src]
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> RealInterpolationOps<S, T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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>,
[src]
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. # Unstable This operation and interpolate_hermite
might be merged into one function with an additional argument in future. Read more
fn interpolate_hermite<B>(
&mut self,
buffer: &mut B,
interpolation_factor: T,
delay: T
) where
B: for<'a> Buffer<'a, S, T>,
[src]
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. # 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, S, NI, DI, NO, DO> PreparedOperation1Exec<S, T, DspVec<S, T, NI, DI>, DspVec<S, T, NO, DO>> for PreparedOperation1<T, NI, DI, NO, DO> where
T: RealNumber,
S: ToSliceMut<T>,
DspVec<S, T, NO, DO>: RededicateForceOps<DspVec<S, T, NI, DI>>,
NI: NumberSpace,
DI: Domain,
NO: NumberSpace,
DO: Domain,
[src]
impl<T, S, NI, DI, NO, DO> PreparedOperation1Exec<S, T, DspVec<S, T, NI, DI>, DspVec<S, T, NO, DO>> for PreparedOperation1<T, NI, DI, NO, DO> where
T: RealNumber,
S: ToSliceMut<T>,
DspVec<S, T, NO, DO>: RededicateForceOps<DspVec<S, T, NI, DI>>,
NI: NumberSpace,
DI: Domain,
NO: NumberSpace,
DO: Domain,
fn exec<B>(
&self,
buffer: &mut B,
a: DspVec<S, T, NI, DI>
) -> Result<DspVec<S, T, NO, DO>, (ErrorReason, DspVec<S, T, NO, DO>)> where
B: for<'a> Buffer<'a, S, T>,
[src]
fn exec<B>(
&self,
buffer: &mut B,
a: DspVec<S, T, NI, DI>
) -> Result<DspVec<S, T, NO, DO>, (ErrorReason, DspVec<S, T, NO, DO>)> where
B: for<'a> Buffer<'a, S, T>,
Executes all recorded operations on the input vectors.
impl<T, S, NI1, DI1, NI2, DI2, NO1, DO1, NO2, DO2> PreparedOperation2Exec<S, T, DspVec<S, T, NI1, DI1>, DspVec<S, T, NI2, DI2>, DspVec<S, T, NO1, DO1>, DspVec<S, T, NO2, DO2>> for PreparedOperation2<T, NI1, DI1, NI2, DI2, NO1, DO1, NO2, DO2> where
T: RealNumber,
S: ToSliceMut<T>,
DspVec<S, T, NO1, DO1>: RededicateForceOps<DspVec<S, T, NI1, DI1>>,
DspVec<S, T, NO2, DO2>: RededicateForceOps<DspVec<S, T, NI2, DI2>>,
NI1: NumberSpace,
DI1: Domain,
NI2: NumberSpace,
DI2: Domain,
NO1: NumberSpace,
DO1: Domain,
NO2: NumberSpace,
DO2: Domain,
[src]
impl<T, S, NI1, DI1, NI2, DI2, NO1, DO1, NO2, DO2> PreparedOperation2Exec<S, T, DspVec<S, T, NI1, DI1>, DspVec<S, T, NI2, DI2>, DspVec<S, T, NO1, DO1>, DspVec<S, T, NO2, DO2>> for PreparedOperation2<T, NI1, DI1, NI2, DI2, NO1, DO1, NO2, DO2> where
T: RealNumber,
S: ToSliceMut<T>,
DspVec<S, T, NO1, DO1>: RededicateForceOps<DspVec<S, T, NI1, DI1>>,
DspVec<S, T, NO2, DO2>: RededicateForceOps<DspVec<S, T, NI2, DI2>>,
NI1: NumberSpace,
DI1: Domain,
NI2: NumberSpace,
DI2: Domain,
NO1: NumberSpace,
DO1: Domain,
NO2: NumberSpace,
DO2: Domain,
fn exec<B>(
&self,
buffer: &mut B,
a: DspVec<S, T, NI1, DI1>,
b: DspVec<S, T, NI2, DI2>
) -> Result<(DspVec<S, T, NO1, DO1>, DspVec<S, T, NO2, DO2>), (ErrorReason, DspVec<S, T, NO1, DO1>, DspVec<S, T, NO2, DO2>)> where
B: for<'a> Buffer<'a, S, T>,
[src]
fn exec<B>(
&self,
buffer: &mut B,
a: DspVec<S, T, NI1, DI1>,
b: DspVec<S, T, NI2, DI2>
) -> Result<(DspVec<S, T, NO1, DO1>, DspVec<S, T, NO2, DO2>), (ErrorReason, DspVec<S, T, NO1, DO1>, DspVec<S, T, NO2, DO2>)> where
B: for<'a> Buffer<'a, S, T>,
Executes all recorded operations on the input vectors.
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,
[src]
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
[src]
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
[src]
fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
Make Other
a Self
without performing any checks. Read more
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,
[src]
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
[src]
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
[src]
fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
Make Other
a Self
without performing any checks. Read more
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,
[src]
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
[src]
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
[src]
fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
Make Other
a Self
without performing any checks. Read more
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,
[src]
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
[src]
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
[src]
fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
Make Other
a Self
without performing any checks. Read more
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,
[src]
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
[src]
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
[src]
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. Read more
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>,
[src]
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
[src]
fn rededicate_from(origin: O) -> Self
Make Other
a Self
. # Example Read more
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>,
[src]
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
[src]
fn rededicate(self) -> O
Converts Self
inot Other
.
impl<S, T, N, D> OffsetOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, N, D> OffsetOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
impl<S, T, N, D> OffsetOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
impl<S, T, N, D> OffsetOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
impl<S, T, D, N> ScaleOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
impl<S, T, D, N> ScaleOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
impl<S, T, D, N> ScaleOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
impl<S, T, D, N> ScaleOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
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> + Index<RangeFull, Output = [T]> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
[src]
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> + Index<RangeFull, Output = [T]> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
fn add(&mut self, summand: &O) -> VoidResult
[src]
fn add(&mut self, summand: &O) -> VoidResult
Calculates the sum of self + summand
. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason
members: Read more
fn sub(&mut self, subtrahend: &O) -> VoidResult
[src]
fn sub(&mut self, subtrahend: &O) -> VoidResult
Calculates the difference of self - subtrahend
. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason
members: Read more
fn mul(&mut self, factor: &O) -> VoidResult
[src]
fn mul(&mut self, factor: &O) -> VoidResult
Calculates the product of self * factor
. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason
members: Read more
fn div(&mut self, divisor: &O) -> VoidResult
[src]
fn div(&mut self, divisor: &O) -> VoidResult
Calculates the quotient of self / summand
. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason
members: Read more
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> + Index<RangeFull, Output = [T]> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
[src]
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> + Index<RangeFull, Output = [T]> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
fn add_smaller(&mut self, summand: &O) -> VoidResult
[src]
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. # Failures TransRes may report the following ErrorReason
members: Read more
fn sub_smaller(&mut self, subtrahend: &O) -> VoidResult
[src]
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. # Failures TransRes may report the following ErrorReason
members: Read more
fn mul_smaller(&mut self, factor: &O) -> VoidResult
[src]
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. # Failures TransRes may report the following ErrorReason
members: Read more
fn div_smaller(&mut self, divisor: &O) -> VoidResult
[src]
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. # Failures TransRes may report the following ErrorReason
members: Read more
impl<S, T, N, D> TrigOps for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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)
[src]
fn sin(&mut self)
Calculates the sine of each element in radians. Read more
fn cos(&mut self)
[src]
fn cos(&mut self)
Calculates the cosine of each element in radians. Read more
fn tan(&mut self)
[src]
fn tan(&mut self)
Calculates the tangent of each element in radians.
fn asin(&mut self)
[src]
fn asin(&mut self)
Calculates the principal value of the inverse sine of each element in radians.
fn acos(&mut self)
[src]
fn acos(&mut self)
Calculates the principal value of the inverse cosine of each element in radians.
fn atan(&mut self)
[src]
fn atan(&mut self)
Calculates the principal value of the inverse tangent of each element in radians.
fn sinh(&mut self)
[src]
fn sinh(&mut self)
Calculates the hyperbolic sine each element in radians.
fn cosh(&mut self)
[src]
fn cosh(&mut self)
Calculates the hyperbolic cosine each element in radians.
fn tanh(&mut self)
[src]
fn tanh(&mut self)
Calculates the hyperbolic tangent each element in radians.
fn asinh(&mut self)
[src]
fn asinh(&mut self)
Calculates the principal value of the inverse hyperbolic sine of each element in radians.
fn acosh(&mut self)
[src]
fn acosh(&mut self)
Calculates the principal value of the inverse hyperbolic cosine of each element in radians.
fn atanh(&mut self)
[src]
fn atanh(&mut self)
Calculates the principal value of the inverse hyperbolic tangent of each element in radians. Read more
impl<S, T, N, D> PowerOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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)
[src]
fn sqrt(&mut self)
Gets the square root of all vector elements. Read more
fn square(&mut self)
[src]
fn square(&mut self)
Squares all vector elements. Read more
fn root(&mut self, degree: T)
[src]
fn root(&mut self, degree: T)
Calculates the n-th root of every vector element. Read more
fn powf(&mut self, exponent: T)
[src]
fn powf(&mut self, exponent: T)
Raises every vector element to a floating point power. Read more
fn ln(&mut self)
[src]
fn ln(&mut self)
Computes the principal value of natural logarithm of every element in the vector. Read more
fn exp(&mut self)
[src]
fn exp(&mut self)
Calculates the natural exponential for every vector element. Read more
fn log(&mut self, base: T)
[src]
fn log(&mut self, base: T)
Calculates the logarithm to the given base for every vector element. Read more
fn expf(&mut self, base: T)
[src]
fn expf(&mut self, base: T)
Calculates the exponential to the given base for every vector element. Read more
impl<S, T, N, D> ReorganizeDataOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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)
[src]
fn reverse(&mut self)
Reverses the data inside the vector. Read more
fn swap_halves(&mut self)
[src]
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
. Read more
impl<S, T, N, D> InsertZerosOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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. Read more
fn zero_interleave(&mut self, factor: u32) -> VoidResult
[src]
fn zero_interleave(&mut self, factor: u32) -> VoidResult
Interleaves zeros factor - 1
times after every vector element, so that the resulting vector will have a length of self.len() * factor
. Read more
impl<S, T, N, D> InsertZerosOpsBuffered<S, T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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>,
[src]
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. Read more
fn zero_interleave_b<B>(&mut self, buffer: &mut B, factor: u32) where
B: for<'a> Buffer<'a, S, T>,
[src]
fn zero_interleave_b<B>(&mut self, buffer: &mut B, factor: u32) where
B: for<'a> Buffer<'a, S, T>,
Interleaves zeros factor - 1
times after every vector element, so that the resulting vector will have a length of self.len() * factor
. Read more
impl<S, T, N, D> SplitOps for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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
. # Failures TransRes may report the following ErrorReason
members: Read more
impl<S, T, N, D> MergeOps for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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
[src]
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. # Failures TransRes may report the following ErrorReason
members: Read more
impl<S, T, N, D> DiffSumOps for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
[src]
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)
[src]
fn diff(&mut self)
Calculates the delta of each elements to its previous element. This will decrease the vector length by one point. Read more
fn diff_with_start(&mut self)
[src]
fn diff_with_start(&mut self)
Calculates the delta of each elements to its previous element. The first element will remain unchanged. Read more
fn cum_sum(&mut self)
[src]
fn cum_sum(&mut self)
Calculates the cumulative sum of all elements. This operation undoes the diff_with_start
operation. Read more
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
[src]
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = ScalarResult<T>
fn dot_product(&self, factor: &O) -> ScalarResult<T>
[src]
fn dot_product(&self, factor: &O) -> ScalarResult<T>
Calculates the dot product of self and factor. Self and factor remain unchanged. Read more
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
[src]
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = ScalarResult<Complex<T>>
fn dot_product(&self, factor: &O) -> ScalarResult<Complex<T>>
[src]
fn dot_product(&self, factor: &O) -> ScalarResult<Complex<T>>
Calculates the dot product of self and factor. Self and factor remain unchanged. Read more
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
[src]
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = ScalarResult<T>
fn dot_product_prec(&self, factor: &O) -> ScalarResult<T>
[src]
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. Read more
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
[src]
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> + Index<RangeFull, Output = [T]>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = ScalarResult<Complex<T>>
fn dot_product_prec(&self, factor: &O) -> ScalarResult<Complex<T>>
[src]
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. Read more
impl<S, T, N, D> MapInplaceOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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,
[src]
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, R> MapAggregateOps<T, R> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
R: Send,
[src]
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,
[src]
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. Read more
impl<S, T, N, D> MapInplaceOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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,
[src]
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, R> MapAggregateOps<Complex<T>, R> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
R: Send,
[src]
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,
[src]
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. Read more
impl<S, T, N, D> StatisticsOps<T> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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>
[src]
fn statistics(&self) -> Statistics<T>
Calculates the statistics of the data. Read more
impl<S, T, N, D> StatisticsSplitOps<T> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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>>>
[src]
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. Read more
impl<S, T, N, D> SumOps<T> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
[src]
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
[src]
fn sum(&self) -> T
Calculates the sum of the data contained in the vector. # Example Read more
fn sum_sq(&self) -> T
[src]
fn sum_sq(&self) -> T
Calculates the sum of the squared data contained in the vector. # Example Read more
impl<S, T, N, D> StatisticsOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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>>
[src]
fn statistics(&self) -> Statistics<Complex<T>>
Calculates the statistics of the data. Read more
impl<S, T, N, D> StatisticsSplitOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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>>>>
[src]
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. Read more
impl<S, T, N, D> SumOps<Complex<T>> for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
[src]
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>
[src]
fn sum(&self) -> Complex<T>
Calculates the sum of the data contained in the vector. # Example Read more
fn sum_sq(&self) -> Complex<T>
[src]
fn sum_sq(&self) -> Complex<T>
Calculates the sum of the squared data contained in the vector. # Example Read more
impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f32, N, D> where
S: ToSlice<f32>,
N: RealNumberSpace,
D: Domain,
[src]
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>
[src]
fn statistics_prec(&self) -> Statistics<f64>
Calculates the statistics of the data contained in the vector using a more precise but slower algorithm. Read more
impl<S, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f32, N, D> where
S: ToSlice<f32>,
N: RealNumberSpace,
D: Domain,
[src]
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>>>
[src]
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. Read more
impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f64, N, D> where
S: ToSlice<f64>,
N: RealNumberSpace,
D: Domain,
[src]
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>
[src]
fn statistics_prec(&self) -> Statistics<f64>
Calculates the statistics of the data contained in the vector using a more precise but slower algorithm. Read more
impl<S, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f64, N, D> where
S: ToSlice<f64>,
N: RealNumberSpace,
D: Domain,
[src]
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>>>
[src]
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. Read more
impl<S, N, D> PreciseSumOps<f64> for DspVec<S, f32, N, D> where
S: ToSlice<f32>,
N: RealNumberSpace,
D: Domain,
[src]
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
[src]
fn sum_prec(&self) -> f64
Calculates the sum of the data contained in the vector using a more precise but slower algorithm. # Example Read more
fn sum_sq_prec(&self) -> f64
[src]
fn sum_sq_prec(&self) -> f64
Calculates the sum of the squared data contained in the vector using a more precise but slower algorithm. # Example Read more
impl<S, N, D> PreciseSumOps<f64> for DspVec<S, f64, N, D> where
S: ToSlice<f64>,
N: RealNumberSpace,
D: Domain,
[src]
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
[src]
fn sum_prec(&self) -> f64
Calculates the sum of the data contained in the vector using a more precise but slower algorithm. # Example Read more
fn sum_sq_prec(&self) -> f64
[src]
fn sum_sq_prec(&self) -> f64
Calculates the sum of the squared data contained in the vector using a more precise but slower algorithm. # Example Read more
impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f32, N, D> where
S: ToSlice<f32>,
N: ComplexNumberSpace,
D: Domain,
[src]
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>>
[src]
fn statistics_prec(&self) -> Statistics<Complex<f64>>
Calculates the statistics of the data contained in the vector using a more precise but slower algorithm. Read more
impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f32, N, D> where
S: ToSlice<f32>,
N: ComplexNumberSpace,
D: Domain,
[src]
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>>>>
[src]
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. Read more
impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f64, N, D> where
S: ToSlice<f64>,
N: ComplexNumberSpace,
D: Domain,
[src]
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>>
[src]
fn statistics_prec(&self) -> Statistics<Complex<f64>>
Calculates the statistics of the data contained in the vector using a more precise but slower algorithm. Read more
impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f64, N, D> where
S: ToSlice<f64>,
N: ComplexNumberSpace,
D: Domain,
[src]
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>>>>
[src]
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. Read more
impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f32, N, D> where
S: ToSlice<f32>,
N: ComplexNumberSpace,
D: Domain,
[src]
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>
[src]
fn sum_prec(&self) -> Complex<f64>
Calculates the sum of the data contained in the vector using a more precise but slower algorithm. # Example Read more
fn sum_sq_prec(&self) -> Complex<f64>
[src]
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. # Example Read more
impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f64, N, D> where
S: ToSlice<f64>,
N: ComplexNumberSpace,
D: Domain,
[src]
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>
[src]
fn sum_prec(&self) -> Complex<f64>
Calculates the sum of the data contained in the vector using a more precise but slower algorithm. # Example Read more
fn sum_sq_prec(&self) -> Complex<f64>
[src]
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. # Example Read more
impl<S, T, N, D> Debug for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
D: Domain,
N: NumberSpace,
[src]
impl<S, T, N, D> Debug for DspVec<S, T, N, D> where
S: ToSlice<T>,
T: RealNumber,
D: Domain,
N: NumberSpace,