Struct basic_dsp_vector::DspVec
source · pub struct DspVec<S, T, N, D>{
pub data: S,
/* private fields */
}
Expand description
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.
Implementations§
source§impl<S, T, N, D> DspVec<S, T, N, D>
impl<S, T, N, D> DspVec<S, T, N, D>
sourcepub fn convolve_mat(
matrix: &[&Self],
impulse_response: &[&Self],
target: &mut [T]
) -> VoidResult
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
.
source§impl<S: ToSliceMut<T>, T: RealNumber> DspVec<S, T, RealOrComplex, TimeOrFreq>
impl<S: ToSliceMut<T>, T: RealNumber> DspVec<S, T, RealOrComplex, TimeOrFreq>
sourcepub fn is_erroneous(&self) -> bool
pub fn is_erroneous(&self) -> bool
Indicates whether or not the operations on this vector have been successful. Consider using the statically typed vector versions so that this check doesn’t need to be performed.
Trait Implementations§
source§impl<S, T, N, D> ApproximatedOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> ApproximatedOps<T> for DspVec<S, T, N, D>
source§fn ln_approx(&mut self)
fn ln_approx(&mut self)
source§fn exp_approx(&mut self)
fn exp_approx(&mut self)
source§fn sin_approx(&mut self)
fn sin_approx(&mut self)
source§fn cos_approx(&mut self)
fn cos_approx(&mut self)
source§fn log_approx(&mut self, base: T)
fn log_approx(&mut self, base: T)
source§fn expf_approx(&mut self, base: T)
fn expf_approx(&mut self, base: T)
source§fn powf_approx(&mut self, exponent: T)
fn powf_approx(&mut self, exponent: T)
source§impl<S, T, N, D> ComplexIndex<RangeFull> for DspVec<S, T, N, D>
impl<S, T, N, D> ComplexIndex<RangeFull> for DspVec<S, T, N, D>
source§impl<S, T, N, D> ComplexIndex<usize> for DspVec<S, T, N, D>
impl<S, T, N, D> ComplexIndex<usize> for DspVec<S, T, N, D>
source§impl<S, T, N, D> ComplexIndexMut<RangeFull> for DspVec<S, T, N, D>
impl<S, T, N, D> ComplexIndexMut<RangeFull> for DspVec<S, T, N, D>
source§impl<S, T, N, D> ComplexIndexMut<usize> for DspVec<S, T, N, D>
impl<S, T, N, D> ComplexIndexMut<usize> for DspVec<S, T, N, D>
source§impl<S, T, N, D> ComplexOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> ComplexOps<T> for DspVec<S, T, N, D>
source§fn multiply_complex_exponential(&mut self, a: T, b: T)
fn multiply_complex_exponential(&mut self, a: T, b: T)
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 moresource§impl<S, T, N, NR, D, O, DO> ComplexToRealGetterOps<O, T, NR, DO> for DspVec<S, T, N, D>where
DspVec<S, T, N, D>: ToRealResult,
O: Vector<T> + GetMetaData<T, NR, DO> + FloatIndex<Range<usize>, Output = [T]> + FloatIndexMut<Range<usize>>,
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
NR: RealNumberSpace,
D: Domain,
DO: PosEq<D> + Domain,
impl<S, T, N, NR, D, O, DO> ComplexToRealGetterOps<O, T, NR, DO> for DspVec<S, T, N, D>where
DspVec<S, T, N, D>: ToRealResult,
O: Vector<T> + GetMetaData<T, NR, DO> + FloatIndex<Range<usize>, Output = [T]> + FloatIndexMut<Range<usize>>,
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
NR: RealNumberSpace,
D: Domain,
DO: PosEq<D> + Domain,
source§fn get_real(&self, destination: &mut O)
fn get_real(&self, destination: &mut O)
source§fn get_imag(&self, destination: &mut O)
fn get_imag(&self, destination: &mut O)
source§fn get_magnitude(&self, destination: &mut O)
fn get_magnitude(&self, destination: &mut O)
source§fn get_magnitude_squared(&self, destination: &mut O)
fn get_magnitude_squared(&self, destination: &mut O)
source§fn get_phase(&self, destination: &mut O)
fn get_phase(&self, destination: &mut O)
source§fn get_real_imag(&self, real: &mut O, imag: &mut O)
fn get_real_imag(&self, real: &mut O, imag: &mut O)
get_phase
and
get_complex_abs
for further
information.source§impl<S, T, N, NR, D, O, DO> ComplexToRealSetterOps<O, T, NR, DO> for DspVec<S, T, N, D>where
DspVec<S, T, N, D>: ToRealResult,
O: FloatIndex<Range<usize>, Output = [T]> + Vector<T> + GetMetaData<T, NR, DO>,
S: ToSliceMut<T> + Resize,
T: RealNumber,
N: ComplexNumberSpace,
NR: RealNumberSpace,
D: Domain,
DO: PosEq<D> + Domain,
impl<S, T, N, NR, D, O, DO> ComplexToRealSetterOps<O, T, NR, DO> for DspVec<S, T, N, D>where
DspVec<S, T, N, D>: ToRealResult,
O: FloatIndex<Range<usize>, Output = [T]> + Vector<T> + GetMetaData<T, NR, DO>,
S: ToSliceMut<T> + Resize,
T: RealNumber,
N: ComplexNumberSpace,
NR: RealNumberSpace,
D: Domain,
DO: PosEq<D> + Domain,
source§fn set_real_imag(&mut self, real: &O, imag: &O) -> VoidResult
fn set_real_imag(&mut self, real: &O, imag: &O) -> VoidResult
self
vectors data with the real and imaginary data in the given vectors.
real
and imag
must have the same size.source§fn set_mag_phase(&mut self, mag: &O, phase: &O) -> VoidResult
fn set_mag_phase(&mut self, mag: &O, phase: &O) -> VoidResult
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.source§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,
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,
source§fn magnitude(self) -> Self::RealResult
fn magnitude(self) -> Self::RealResult
source§fn magnitude_squared(self) -> Self::RealResult
fn magnitude_squared(self) -> Self::RealResult
source§fn to_real(self) -> Self::RealResult
fn to_real(self) -> Self::RealResult
source§fn to_imag(self) -> Self::RealResult
fn to_imag(self) -> Self::RealResult
source§fn phase(self) -> Self::RealResult
fn phase(self) -> Self::RealResult
source§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,
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,
source§fn magnitude_b<B>(self, buffer: &mut B) -> Self::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn magnitude_b<B>(self, buffer: &mut B) -> Self::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn magnitude_squared_b<B>(self, buffer: &mut B) -> Self::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn magnitude_squared_b<B>(self, buffer: &mut B) -> Self::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn to_real_b<B>(self, buffer: &mut B) -> Self::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn to_real_b<B>(self, buffer: &mut B) -> Self::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<'a, S, T, N, D> Convolution<'a, S, T, &'a dyn 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>,
impl<'a, S, T, N, D> Convolution<'a, S, T, &'a dyn 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>,
source§fn convolve<B>(
&mut self,
buffer: &mut B,
function: &dyn ComplexImpulseResponse<T>,
ratio: T,
len: usize
)where
B: for<'b> Buffer<'b, S, T>,
fn convolve<B>(
&mut self,
buffer: &mut B,
function: &dyn ComplexImpulseResponse<T>,
ratio: T,
len: usize
)where
B: for<'b> Buffer<'b, S, T>,
self
with the convolution function impulse_response
.
For performance consider to
to use FrequencyMultiplication
instead of this operation depending on len
. Read moresource§impl<'a, S, T, N, D> Convolution<'a, S, T, &'a dyn 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>,
impl<'a, S, T, N, D> Convolution<'a, S, T, &'a dyn 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>,
source§fn convolve<B>(
&mut self,
buffer: &mut B,
function: &dyn RealImpulseResponse<T>,
ratio: T,
len: usize
)where
B: for<'b> Buffer<'b, S, T>,
fn convolve<B>(
&mut self,
buffer: &mut B,
function: &dyn RealImpulseResponse<T>,
ratio: T,
len: usize
)where
B: for<'b> Buffer<'b, S, T>,
self
with the convolution function impulse_response
.
For performance consider to
to use FrequencyMultiplication
instead of this operation depending on len
. Read moresource§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,
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,
source§fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<SO, T, NO, DO>
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<SO, T, NO, DO>
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
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 moresource§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,
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,
source§fn prepare_argument<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn prepare_argument<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn prepare_argument_padded<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn prepare_argument_padded<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
2 * self.points() - 1
and then the same operations are performed as described for prepare_argument
.source§impl<S, T, N, D, DF, O, NO> CrossCorrelationOps<O, S, T, NO, DF> for DspVec<S, T, N, D>where
DspVec<S, T, N, D>: ScaleOps<T>,
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: TimeDomain,
DF: FrequencyDomain,
O: Vector<T> + GetMetaData<T, NO, DF>,
NO: PosEq<N> + NumberSpace,
impl<S, T, N, D, DF, O, NO> CrossCorrelationOps<O, S, T, NO, DF> for DspVec<S, T, N, D>where
DspVec<S, T, N, D>: ScaleOps<T>,
S: ToSliceMut<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: TimeDomain,
DF: FrequencyDomain,
O: Vector<T> + GetMetaData<T, NO, DF>,
NO: PosEq<N> + NumberSpace,
source§fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
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.source§impl<S, T, N, D> DiffSumOps for DspVec<S, T, N, D>
impl<S, T, N, D> DiffSumOps for DspVec<S, T, N, D>
source§impl<S, O, T, N, D, NO, DO> DotProductOps<O, Complex<T>, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
impl<S, O, T, N, D, NO, DO> DotProductOps<O, Complex<T>, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = Result<Complex<T>, ErrorReason>
source§fn dot_product(&self, factor: &O) -> ScalarResult<Complex<T>>
fn dot_product(&self, factor: &O) -> ScalarResult<Complex<T>>
source§impl<S, O, T, N, D, NO, DO> DotProductOps<O, T, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
impl<S, O, T, N, D, NO, DO> DotProductOps<O, T, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = Result<T, ErrorReason>
source§fn dot_product(&self, factor: &O) -> ScalarResult<T>
fn dot_product(&self, factor: &O) -> ScalarResult<T>
source§impl<S, T, N, D, O, NO, DO> ElementaryOps<O, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
impl<S, T, N, D, O, NO, DO> ElementaryOps<O, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
source§fn add(&mut self, summand: &O) -> VoidResult
fn add(&mut self, summand: &O) -> VoidResult
self + summand
. It consumes self and returns the result. Read moresource§fn sub(&mut self, subtrahend: &O) -> VoidResult
fn sub(&mut self, subtrahend: &O) -> VoidResult
self - subtrahend
. It consumes self and returns the result. Read moresource§impl<S, T, N, D, O, NO, DO> ElementaryWrapAroundOps<O, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
impl<S, T, N, D, O, NO, DO> ElementaryWrapAroundOps<O, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
source§fn add_smaller(&mut self, summand: &O) -> VoidResult
fn add_smaller(&mut self, summand: &O) -> VoidResult
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. Read moresource§fn sub_smaller(&mut self, subtrahend: &O) -> VoidResult
fn sub_smaller(&mut self, subtrahend: &O) -> VoidResult
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. Read moresource§fn mul_smaller(&mut self, factor: &O) -> VoidResult
fn mul_smaller(&mut self, factor: &O) -> VoidResult
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. Read moresource§fn div_smaller(&mut self, divisor: &O) -> VoidResult
fn div_smaller(&mut self, divisor: &O) -> VoidResult
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. Read moresource§impl<S, T, N, D> FloatIndex<RangeFull> for DspVec<S, T, N, D>
impl<S, T, N, D> FloatIndex<RangeFull> for DspVec<S, T, N, D>
source§impl<S, T, N, D> FloatIndex<usize> for DspVec<S, T, N, D>
impl<S, T, N, D> FloatIndex<usize> for DspVec<S, T, N, D>
source§impl<S, T, N, D> FloatIndexMut<RangeFull> for DspVec<S, T, N, D>
impl<S, T, N, D> FloatIndexMut<RangeFull> for DspVec<S, T, N, D>
source§impl<S, T, N, D> FloatIndexMut<usize> for DspVec<S, T, N, D>
impl<S, T, N, D> FloatIndexMut<usize> for DspVec<S, T, N, D>
source§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,
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,
source§fn mirror<B>(&mut self, buffer: &mut B)where
B: for<'a> Buffer<'a, S, T>,
fn mirror<B>(&mut self, buffer: &mut B)where
B: for<'a> Buffer<'a, S, T>,
source§fn ifft_shift(&mut self)
fn ifft_shift(&mut self)
source§impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a dyn ComplexFrequencyResponse<T>> for DspVec<S, T, N, D>
impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a dyn ComplexFrequencyResponse<T>> for DspVec<S, T, N, D>
source§fn multiply_frequency_response(
&mut self,
frequency_response: &dyn ComplexFrequencyResponse<T>,
ratio: T
)
fn multiply_frequency_response( &mut self, frequency_response: &dyn ComplexFrequencyResponse<T>, ratio: T )
source§impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a dyn RealFrequencyResponse<T>> for DspVec<S, T, N, D>
impl<'a, S, T, N, D> FrequencyMultiplication<'a, S, T, &'a dyn RealFrequencyResponse<T>> for DspVec<S, T, N, D>
source§fn multiply_frequency_response(
&mut self,
frequency_response: &dyn RealFrequencyResponse<T>,
ratio: T
)
fn multiply_frequency_response( &mut self, frequency_response: &dyn RealFrequencyResponse<T>, ratio: T )
source§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,
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,
source§fn plain_ifft<B>(self, buffer: &mut B) -> Self::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
fn plain_ifft<B>(self, buffer: &mut B) -> Self::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn ifft<B>(self, buffer: &mut B) -> Self::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
fn ifft<B>(self, buffer: &mut B) -> Self::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn windowed_ifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> Self::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
fn windowed_ifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> Self::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<T, D> From<DspVec<Vec<T>, T, Complex, D>> for Vec<Complex<T>>where
T: RealNumber,
D: Domain,
impl<T, D> From<DspVec<Vec<T>, T, Complex, D>> for Vec<Complex<T>>where
T: RealNumber,
D: Domain,
source§impl<'a, T, D> FromVector<T> for DspVec<&'a [T], T, Complex, D>where
T: RealNumber,
D: Domain,
impl<'a, T, D> FromVector<T> for DspVec<&'a [T], T, Complex, D>where
T: RealNumber,
D: Domain,
source§impl<'a, T, D> FromVector<T> for DspVec<&'a mut [T], T, Complex, D>where
T: RealNumber,
D: Domain,
impl<'a, T, D> FromVector<T> for DspVec<&'a mut [T], T, Complex, D>where
T: RealNumber,
D: Domain,
source§impl<S, T, D> FromVector<T> for DspVec<S, T, Real, D>
impl<S, T, D> FromVector<T> for DspVec<S, T, Real, D>
source§impl<T, D> FromVector<T> for DspVec<Vec<T>, T, Complex, D>where
T: RealNumber,
D: Domain,
impl<T, D> FromVector<T> for DspVec<Vec<T>, T, Complex, D>where
T: RealNumber,
D: Domain,
source§impl<S, T, N, D> FromVectorFloat<T> for DspVec<S, T, N, D>
impl<S, T, N, D> FromVectorFloat<T> for DspVec<S, T, N, D>
source§fn getf(self) -> (Self::Output, usize)
fn getf(self) -> (Self::Output, usize)
Into
or FromVector
for a method which returns the data of complex vectors in a different manner. Read moresource§impl<S, T, N, D> GetMetaData<T, N, D> for DspVec<S, T, N, D>
impl<S, T, N, D> GetMetaData<T, N, D> for DspVec<S, T, N, D>
source§fn get_meta_data(&self) -> TypeMetaData<T, N, D>
fn get_meta_data(&self) -> TypeMetaData<T, N, D>
source§impl<S, T, N, D> InsertZerosOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> InsertZerosOps<T> for DspVec<S, T, N, D>
source§fn zero_pad(&mut self, points: usize, option: PaddingOption) -> VoidResult
fn zero_pad(&mut self, points: usize, option: PaddingOption) -> VoidResult
points
smaller than the self.len()
then this operation won’t do anything, however
in future it will raise an error. Read moresource§fn zero_interleave(&mut self, factor: u32) -> VoidResult
fn zero_interleave(&mut self, factor: u32) -> VoidResult
factor - 1
times after every vector element, so that the resulting
vector will have a length of self.len() * factor
. Read moresource§impl<S, T, N, D> InsertZerosOpsBuffered<S, T> for DspVec<S, T, N, D>
impl<S, T, N, D> InsertZerosOpsBuffered<S, T> for DspVec<S, T, N, D>
source§fn zero_pad_b<B>(
&mut self,
buffer: &mut B,
points: usize,
option: PaddingOption
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
fn zero_pad_b<B>(
&mut self,
buffer: &mut B,
points: usize,
option: PaddingOption
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
points
smaller than the self.len()
then this operation will return an error. Read moresource§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,
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,
source§fn interpolatef<B>(
&mut self,
buffer: &mut B,
function: &dyn RealImpulseResponse<T>,
interpolation_factor: T,
delay: T,
conv_len: usize
)where
B: for<'a> Buffer<'a, S, T>,
fn interpolatef<B>(
&mut self,
buffer: &mut B,
function: &dyn RealImpulseResponse<T>,
interpolation_factor: T,
delay: T,
conv_len: usize
)where
B: for<'a> Buffer<'a, S, T>,
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 moresource§fn interpolatei<B>(
&mut self,
buffer: &mut B,
function: &dyn RealFrequencyResponse<T>,
interpolation_factor: u32
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
fn interpolatei<B>(
&mut self,
buffer: &mut B,
function: &dyn RealFrequencyResponse<T>,
interpolation_factor: u32
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
self
with the convolution function function
by the integer value
interpolation_factor
. InterpolationOps is done in in frequency domain. Read moresource§fn interpft<B>(&mut self, buffer: &mut B, dest_points: usize)where
B: for<'a> Buffer<'a, S, T>,
fn interpft<B>(&mut self, buffer: &mut B, dest_points: usize)where
B: for<'a> Buffer<'a, S, T>,
source§fn interpolate<B>(
&mut self,
buffer: &mut B,
function: Option<&dyn RealFrequencyResponse<T>>,
dest_points: usize,
delay: T
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
fn interpolate<B>(
&mut self,
buffer: &mut B,
function: Option<&dyn RealFrequencyResponse<T>>,
dest_points: usize,
delay: T
) -> VoidResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<S, T, N, D, R> MapAggregateOps<Complex<T>, R> for DspVec<S, T, N, D>
impl<S, T, N, D, R> MapAggregateOps<Complex<T>, R> for DspVec<S, T, N, D>
type Output = Result<R, ErrorReason>
source§fn map_aggregate<'a, A, FMap, FAggr>(
&self,
argument: A,
map: &FMap,
aggregate: &FAggr
) -> ScalarResult<R>
fn map_aggregate<'a, A, FMap, FAggr>( &self, argument: A, map: &FMap, aggregate: &FAggr ) -> ScalarResult<R>
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.source§impl<S, T, N, D, R> MapAggregateOps<T, R> for DspVec<S, T, N, D>
impl<S, T, N, D, R> MapAggregateOps<T, R> for DspVec<S, T, N, D>
type Output = Result<R, ErrorReason>
source§fn map_aggregate<'a, A, FMap, FAggr>(
&self,
argument: A,
map: &FMap,
aggregate: &FAggr
) -> ScalarResult<R>
fn map_aggregate<'a, A, FMap, FAggr>( &self, argument: A, map: &FMap, aggregate: &FAggr ) -> ScalarResult<R>
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.source§impl<S, T, N, D> MapInplaceOps<Complex<T>> for DspVec<S, T, N, D>
impl<S, T, N, D> MapInplaceOps<Complex<T>> for DspVec<S, T, N, D>
source§impl<S, T, N, D> MapInplaceOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> MapInplaceOps<T> for DspVec<S, T, N, D>
source§impl<S, T, N, D> MetaData for DspVec<S, T, N, D>
impl<S, T, N, D> MetaData for DspVec<S, T, N, D>
source§fn domain(&self) -> DataDomain
fn domain(&self) -> DataDomain
source§fn is_complex(&self) -> bool
fn is_complex(&self) -> bool
source§impl<S, T, N, D> ModuloOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> ModuloOps<T> for DspVec<S, T, N, D>
source§impl<S, T, N, D> PowerOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> PowerOps<T> for DspVec<S, T, N, D>
source§fn powf(&mut self, exponent: T)
fn powf(&mut self, exponent: T)
source§fn ln(&mut self)
fn ln(&mut self)
source§impl<S, O, T, N, D, NO, DO> PreciseDotProductOps<O, Complex<T>, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
impl<S, O, T, N, D, NO, DO> PreciseDotProductOps<O, Complex<T>, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: ComplexNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = Result<Complex<T>, ErrorReason>
source§fn dot_product_prec(&self, factor: &O) -> ScalarResult<Complex<T>>
fn dot_product_prec(&self, factor: &O) -> ScalarResult<Complex<T>>
source§impl<S, O, T, N, D, NO, DO> PreciseDotProductOps<O, T, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
impl<S, O, T, N, D, NO, DO> PreciseDotProductOps<O, T, T, NO, DO> for DspVec<S, T, N, D>where
S: ToSlice<T>,
T: RealNumber,
N: RealNumberSpace,
D: Domain,
O: Vector<T> + GetMetaData<T, NO, DO>,
NO: PosEq<N> + NumberSpace,
DO: PosEq<D> + Domain,
type Output = Result<T, ErrorReason>
source§fn dot_product_prec(&self, factor: &O) -> ScalarResult<T>
fn dot_product_prec(&self, factor: &O) -> ScalarResult<T>
source§impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f32, N, D>
impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f32, N, D>
type Result = Statistics<Complex<f64>>
source§fn statistics_prec(&self) -> Statistics<Complex<f64>>
fn statistics_prec(&self) -> Statistics<Complex<f64>>
source§impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f64, N, D>
impl<S, N, D> PreciseStatisticsOps<Complex<f64>> for DspVec<S, f64, N, D>
type Result = Statistics<Complex<f64>>
source§fn statistics_prec(&self) -> Statistics<Complex<f64>>
fn statistics_prec(&self) -> Statistics<Complex<f64>>
source§impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f32, N, D>
impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f32, N, D>
type Result = Statistics<f64>
source§fn statistics_prec(&self) -> Statistics<f64>
fn statistics_prec(&self) -> Statistics<f64>
source§impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f64, N, D>
impl<S, N, D> PreciseStatisticsOps<f64> for DspVec<S, f64, N, D>
type Result = Statistics<f64>
source§fn statistics_prec(&self) -> Statistics<f64>
fn statistics_prec(&self) -> Statistics<f64>
source§impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f32, N, D>
impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f32, N, D>
type Result = ArrayVec<Statistics<Complex<f64>>, STATS_VEC_CAPACTIY>
source§fn statistics_split_prec(
&self,
len: usize
) -> ScalarResult<StatsVec<Statistics<Complex<f64>>>>
fn statistics_split_prec( &self, len: usize ) -> ScalarResult<StatsVec<Statistics<Complex<f64>>>>
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 moresource§impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f64, N, D>
impl<S, N, D> PreciseStatisticsSplitOps<Complex<f64>> for DspVec<S, f64, N, D>
type Result = ArrayVec<Statistics<Complex<f64>>, STATS_VEC_CAPACTIY>
source§fn statistics_split_prec(
&self,
len: usize
) -> ScalarResult<StatsVec<Statistics<Complex<f64>>>>
fn statistics_split_prec( &self, len: usize ) -> ScalarResult<StatsVec<Statistics<Complex<f64>>>>
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 moresource§impl<S, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f32, N, D>
impl<S, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f32, N, D>
type Result = ArrayVec<Statistics<f64>, STATS_VEC_CAPACTIY>
source§fn statistics_split_prec(
&self,
len: usize
) -> ScalarResult<StatsVec<Statistics<f64>>>
fn statistics_split_prec( &self, len: usize ) -> ScalarResult<StatsVec<Statistics<f64>>>
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 moresource§impl<S, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f64, N, D>
impl<S, N, D> PreciseStatisticsSplitOps<f64> for DspVec<S, f64, N, D>
type Result = ArrayVec<Statistics<f64>, STATS_VEC_CAPACTIY>
source§fn statistics_split_prec(
&self,
len: usize
) -> ScalarResult<StatsVec<Statistics<f64>>>
fn statistics_split_prec( &self, len: usize ) -> ScalarResult<StatsVec<Statistics<f64>>>
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 moresource§impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f32, N, D>
impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f32, N, D>
source§impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f64, N, D>
impl<S, N, D> PreciseSumOps<Complex<f64>> for DspVec<S, f64, N, D>
source§impl<S, T, N, D> RealInterpolationOps<S, T> for DspVec<S, T, N, D>
impl<S, T, N, D> RealInterpolationOps<S, T> for DspVec<S, T, N, D>
source§fn interpolate_lin<B>(
&mut self,
buffer: &mut B,
interpolation_factor: T,
delay: T
)where
B: for<'a> Buffer<'a, S, T>,
fn interpolate_lin<B>(
&mut self,
buffer: &mut B,
interpolation_factor: T,
delay: T
)where
B: for<'a> Buffer<'a, S, T>,
source§fn interpolate_hermite<B>(
&mut self,
buffer: &mut B,
interpolation_factor: T,
delay: T
)where
B: for<'a> Buffer<'a, S, T>,
fn interpolate_hermite<B>(
&mut self,
buffer: &mut B,
interpolation_factor: T,
delay: T
)where
B: for<'a> Buffer<'a, S, T>,
source§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,
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,
source§fn to_complex(self) -> TransRes<Self::ComplexResult>
fn to_complex(self) -> TransRes<Self::ComplexResult>
source§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,
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,
source§fn to_complex_b<B>(self, buffer: &mut B) -> Self::ComplexResultwhere
B: for<'a> Buffer<'a, S, T>,
fn to_complex_b<B>(self, buffer: &mut B) -> Self::ComplexResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for ComplexFreqVec<S, T>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for ComplexFreqVec<S, T>
source§fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
Other
a Self
without performing any checks.source§fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
fn rededicate_with_runtime_data( origin: DspVec<S, T, N, D>, _: bool, _: DataDomain ) -> Self
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for ComplexTimeVec<S, T>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for ComplexTimeVec<S, T>
source§fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
Other
a Self
without performing any checks.source§fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
fn rededicate_with_runtime_data( origin: DspVec<S, T, N, D>, _: bool, _: DataDomain ) -> Self
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for RealFreqVec<S, T>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for RealFreqVec<S, T>
source§fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
Other
a Self
without performing any checks.source§fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
fn rededicate_with_runtime_data( origin: DspVec<S, T, N, D>, _: bool, _: DataDomain ) -> Self
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for RealTimeVec<S, T>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for RealTimeVec<S, T>
source§fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
Other
a Self
without performing any checks.source§fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
_: bool,
_: DataDomain
) -> Self
fn rededicate_with_runtime_data( origin: DspVec<S, T, N, D>, _: bool, _: DataDomain ) -> Self
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for GenDspVec<S, T>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for GenDspVec<S, T>
source§fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
fn rededicate_from_force(origin: DspVec<S, T, N, D>) -> Self
Other
a Self
without performing any checks.source§fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
is_complex: bool,
domain: DataDomain
) -> Self
fn rededicate_with_runtime_data( origin: DspVec<S, T, N, D>, is_complex: bool, domain: DataDomain ) -> Self
source§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>,
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>,
source§fn rededicate_from(origin: O) -> Self
fn rededicate_from(origin: O) -> Self
source§impl<S, T, N, D, O> RededicateToOps<O> for DspVec<S, T, N, D>
impl<S, T, N, D, O> RededicateToOps<O> for DspVec<S, T, N, D>
source§fn rededicate(self) -> O
fn rededicate(self) -> O
Self
inot Other
.source§impl<S, T, N, D> ReorganizeDataOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> ReorganizeDataOps<T> for DspVec<S, T, N, D>
source§impl<S, T, N, D> ResizeBufferedOps<S, T> for DspVec<S, T, N, D>
impl<S, T, N, D> ResizeBufferedOps<S, T> for DspVec<S, T, N, D>
source§impl<S, T, N, D> ResizeOps for DspVec<S, T, N, D>
impl<S, T, N, D> ResizeOps for DspVec<S, T, N, D>
source§fn resize(&mut self, len: usize) -> VoidResult
fn resize(&mut self, len: usize) -> VoidResult
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.source§impl<S, T, N, D> SplitOps for DspVec<S, T, N, D>
impl<S, T, N, D> SplitOps for DspVec<S, T, N, D>
source§fn split_into(&self, targets: &mut [&mut Self]) -> VoidResult
fn split_into(&self, targets: &mut [&mut Self]) -> VoidResult
self.len()
must be dividable by
targets.len()
without a remainder and this condition must be true too
targets.len() > 0
. Read moresource§impl<S, T, N, D> StatisticsOps<Complex<T>> for DspVec<S, T, N, D>
impl<S, T, N, D> StatisticsOps<Complex<T>> for DspVec<S, T, N, D>
type Result = Statistics<Complex<T>>
source§fn statistics(&self) -> Statistics<Complex<T>>
fn statistics(&self) -> Statistics<Complex<T>>
source§impl<S, T, N, D> StatisticsOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> StatisticsOps<T> for DspVec<S, T, N, D>
type Result = Statistics<T>
source§fn statistics(&self) -> Statistics<T>
fn statistics(&self) -> Statistics<T>
source§impl<S, T, N, D> StatisticsSplitOps<Complex<T>> for DspVec<S, T, N, D>
impl<S, T, N, D> StatisticsSplitOps<Complex<T>> for DspVec<S, T, N, D>
type Result = ArrayVec<Statistics<Complex<T>>, STATS_VEC_CAPACTIY>
source§fn statistics_split(
&self,
len: usize
) -> ScalarResult<StatsVec<Statistics<Complex<T>>>>
fn statistics_split( &self, len: usize ) -> ScalarResult<StatsVec<Statistics<Complex<T>>>>
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 moresource§impl<S, T, N, D> StatisticsSplitOps<T> for DspVec<S, T, N, D>
impl<S, T, N, D> StatisticsSplitOps<T> for DspVec<S, T, N, D>
type Result = ArrayVec<Statistics<T>, STATS_VEC_CAPACTIY>
source§fn statistics_split(&self, len: usize) -> ScalarResult<StatsVec<Statistics<T>>>
fn statistics_split(&self, len: usize) -> ScalarResult<StatsVec<Statistics<T>>>
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 moresource§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,
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,
source§fn plain_sifft<B>(self, buffer: &mut B) -> TransRes<Self::RealTimeResult>where
B: for<'a> Buffer<'a, S, T>,
fn plain_sifft<B>(self, buffer: &mut B) -> TransRes<Self::RealTimeResult>where
B: for<'a> Buffer<'a, S, T>,
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 moresource§fn sifft<B>(self, buffer: &mut B) -> TransRes<Self::RealTimeResult>where
B: for<'a> Buffer<'a, S, T>,
fn sifft<B>(self, buffer: &mut B) -> TransRes<Self::RealTimeResult>where
B: for<'a> Buffer<'a, S, T>,
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 moresource§fn windowed_sifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> TransRes<Self::RealTimeResult>where
B: for<'a> Buffer<'a, S, T>,
fn windowed_sifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> TransRes<Self::RealTimeResult>where
B: for<'a> Buffer<'a, S, T>,
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 moresource§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,
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,
source§fn plain_sfft<B>(self, buffer: &mut B) -> TransRes<Self::FreqResult>where
B: for<'a> Buffer<'a, S, T>,
fn plain_sfft<B>(self, buffer: &mut B) -> TransRes<Self::FreqResult>where
B: for<'a> Buffer<'a, S, T>,
self
is symmetric around the center. This assumption
isn’t verified and no error is raised if the vector isn’t symmetric. Read moresource§fn sfft<B>(self, buffer: &mut B) -> TransRes<Self::FreqResult>where
B: for<'a> Buffer<'a, S, T>,
fn sfft<B>(self, buffer: &mut B) -> TransRes<Self::FreqResult>where
B: for<'a> Buffer<'a, S, T>,
self
is symmetric around the center. This assumption
isn’t verified and no error is raised if the vector isn’t symmetric. Read moresource§fn windowed_sfft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> TransRes<Self::FreqResult>where
B: for<'a> Buffer<'a, S, T>,
fn windowed_sfft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> TransRes<Self::FreqResult>where
B: for<'a> Buffer<'a, S, T>,
self
is symmetric around the center. This assumption
isn’t verified and no error is raised if the vector isn’t symmetric. Read moresource§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,
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,
source§fn apply_window(&mut self, window: &dyn WindowFunction<T>)
fn apply_window(&mut self, window: &dyn WindowFunction<T>)
source§fn unapply_window(&mut self, window: &dyn WindowFunction<T>)
fn unapply_window(&mut self, window: &dyn WindowFunction<T>)
source§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,
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,
source§fn plain_fft<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn plain_fft<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn fft<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn fft<B>(self, buffer: &mut B) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn windowed_fft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn windowed_fft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> Self::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<S, T, N, D> TrigOps for DspVec<S, T, N, D>
impl<S, T, N, D> TrigOps for DspVec<S, T, N, D>
source§fn asin(&mut self)
fn asin(&mut self)
source§fn acos(&mut self)
fn acos(&mut self)
source§fn atan(&mut self)
fn atan(&mut self)
source§fn asinh(&mut self)
fn asinh(&mut self)
source§impl<S, T, N, D> Vector<T> for DspVec<S, T, N, D>
impl<S, T, N, D> Vector<T> for DspVec<S, T, N, D>
source§fn delta(&self) -> T
fn delta(&self) -> T
domain
is time domain then delta
is in [s]
,
in frequency domain delta
is in [Hz]
.source§fn set_delta(&mut self, delta: T)
fn set_delta(&mut self, delta: T)
domain
is time domain then delta
is in [s]
,
in frequency domain delta
is in [Hz]
.source§fn len(&self) -> usize
fn len(&self) -> usize
Resize
trait.