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: &[&DspVec<S, T, N, D>],
impulse_response: &[&DspVec<S, T, N, D>],
target: &mut [T]
) -> Result<(), ErrorReason>
pub fn convolve_mat( matrix: &[&DspVec<S, T, N, D>], impulse_response: &[&DspVec<S, T, N, D>], target: &mut [T] ) -> Result<(), ErrorReason>
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, T> DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSliceMut<T>,
T: RealNumber,
impl<S, T> DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSliceMut<T>,
T: RealNumber,
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, Output = [T]> + GetMetaData<T, NR, DO> + FloatIndex<Range<usize>> + 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, Output = [T]> + GetMetaData<T, NR, DO> + FloatIndex<Range<usize>> + 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) -> Result<(), ErrorReason>
fn set_real_imag(&mut self, real: &O, imag: &O) -> Result<(), ErrorReason>
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) -> Result<(), ErrorReason>
fn set_mag_phase(&mut self, mag: &O, phase: &O) -> Result<(), ErrorReason>
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) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
fn magnitude(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
source§fn magnitude_squared(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
fn magnitude_squared(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
source§fn to_real(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
fn to_real(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
source§fn to_imag(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
fn to_imag(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
source§fn phase(self) -> <DspVec<S, T, N, D> as ToRealResult>::RealResult
fn phase(self) -> <DspVec<S, T, N, D> as ToRealResult>::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
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn magnitude_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn magnitude_squared_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn magnitude_squared_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn to_real_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn to_real_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn to_imag_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn to_imag_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn phase_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::RealResultwhere
B: for<'a> Buffer<'a, S, T>,
fn phase_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToRealResult>::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, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix2xN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
impl<S, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix2xN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
source§fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, S, T>,
fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, 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> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix3xN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
impl<S, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix3xN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
source§fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, S, T>,
fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, 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> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix4xN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
impl<S, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for Matrix4xN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
source§fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, S, T>,
fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, 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> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for MatrixMxN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
impl<S, T, N, D> ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D> for MatrixMxN<DspVec<S, T, N, D>, S, T>where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,
DspVec<S, T, N, D>: ConvolutionOps<DspVec<S, T, N, D>, S, T, N, D>,
source§fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, S, T>,
fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<S, T, N, D>
) -> Result<(), ErrorReason>where
B: for<'b> Buffer<'b, 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, 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>
) -> Result<(), ErrorReason>where
B: for<'a> Buffer<'a, S, T>,
fn convolve_signal<B>(
&mut self,
buffer: &mut B,
impulse_response: &DspVec<SO, T, NO, DO>
) -> Result<(), ErrorReason>where
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
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn prepare_argument<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn prepare_argument_padded<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn prepare_argument_padded<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToFreqResult>::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) -> Result<(), ErrorReason>where
B: for<'a> Buffer<'a, S, T>,
fn correlate<B>(&mut self, buffer: &mut B, other: &O) -> Result<(), ErrorReason>where
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) -> Result<Complex<T>, ErrorReason>
fn dot_product(&self, factor: &O) -> Result<Complex<T>, ErrorReason>
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) -> Result<T, ErrorReason>
fn dot_product(&self, factor: &O) -> Result<T, ErrorReason>
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) -> Result<(), ErrorReason>
fn add(&mut self, summand: &O) -> Result<(), ErrorReason>
self + summand
. It consumes self and returns the result. Read moresource§fn sub(&mut self, subtrahend: &O) -> Result<(), ErrorReason>
fn sub(&mut self, subtrahend: &O) -> Result<(), ErrorReason>
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) -> Result<(), ErrorReason>
fn add_smaller(&mut self, summand: &O) -> Result<(), ErrorReason>
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) -> Result<(), ErrorReason>
fn sub_smaller(&mut self, subtrahend: &O) -> Result<(), ErrorReason>
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) -> Result<(), ErrorReason>
fn mul_smaller(&mut self, factor: &O) -> Result<(), ErrorReason>
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) -> Result<(), ErrorReason>
fn div_smaller(&mut self, divisor: &O) -> Result<(), ErrorReason>
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
) -> <DspVec<S, T, N, D> as ToTimeResult>::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
fn plain_ifft<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToTimeResult>::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn ifft<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToTimeResult>::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
fn ifft<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToTimeResult>::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn windowed_ifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> <DspVec<S, T, N, D> as ToTimeResult>::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
fn windowed_ifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> <DspVec<S, T, N, D> as ToTimeResult>::TimeResultwhere
B: for<'a> Buffer<'a, S, T>,
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) -> (<DspVec<S, T, N, D> as FromVectorFloat<T>>::Output, usize)
fn getf(self) -> (<DspVec<S, T, N, D> as FromVectorFloat<T>>::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
) -> Result<(), ErrorReason>
fn zero_pad( &mut self, points: usize, option: PaddingOption ) -> Result<(), ErrorReason>
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) -> Result<(), ErrorReason>
fn zero_interleave(&mut self, factor: u32) -> Result<(), ErrorReason>
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
) -> Result<(), ErrorReason>where
B: for<'a> Buffer<'a, S, T>,
fn zero_pad_b<B>(
&mut self,
buffer: &mut B,
points: usize,
option: PaddingOption
) -> Result<(), ErrorReason>where
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
) -> Result<(), ErrorReason>where
B: for<'a> Buffer<'a, S, T>,
fn interpolatei<B>(
&mut self,
buffer: &mut B,
function: &dyn RealFrequencyResponse<T>,
interpolation_factor: u32
) -> Result<(), ErrorReason>where
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
) -> Result<(), ErrorReason>where
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
) -> Result<(), ErrorReason>where
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
) -> Result<R, ErrorReason>
fn map_aggregate<'a, A, FMap, FAggr>( &self, argument: A, map: &FMap, aggregate: &FAggr ) -> Result<R, ErrorReason>
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
) -> Result<R, ErrorReason>
fn map_aggregate<'a, A, FMap, FAggr>( &self, argument: A, map: &FMap, aggregate: &FAggr ) -> Result<R, ErrorReason>
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) -> Result<Complex<T>, ErrorReason>
fn dot_product_prec(&self, factor: &O) -> Result<Complex<T>, ErrorReason>
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) -> Result<T, ErrorReason>
fn dot_product_prec(&self, factor: &O) -> Result<T, ErrorReason>
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>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>
source§fn statistics_split_prec(
&self,
len: usize
) -> Result<ArrayVec<Statistics<Complex<f64>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
fn statistics_split_prec( &self, len: usize ) -> Result<ArrayVec<Statistics<Complex<f64>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
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>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>
source§fn statistics_split_prec(
&self,
len: usize
) -> Result<ArrayVec<Statistics<Complex<f64>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
fn statistics_split_prec( &self, len: usize ) -> Result<ArrayVec<Statistics<Complex<f64>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
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>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>
source§fn statistics_split_prec(
&self,
len: usize
) -> Result<ArrayVec<Statistics<f64>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
fn statistics_split_prec( &self, len: usize ) -> Result<ArrayVec<Statistics<f64>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
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>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>
source§fn statistics_split_prec(
&self,
len: usize
) -> Result<ArrayVec<Statistics<f64>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
fn statistics_split_prec( &self, len: usize ) -> Result<ArrayVec<Statistics<f64>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
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
) -> Result<<DspVec<S, T, N, D> as ToComplexResult>::ComplexResult, (ErrorReason, <DspVec<S, T, N, D> as ToComplexResult>::ComplexResult)>
fn to_complex( self ) -> Result<<DspVec<S, T, N, D> as ToComplexResult>::ComplexResult, (ErrorReason, <DspVec<S, T, N, D> as ToComplexResult>::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
) -> <DspVec<S, T, N, D> as ToComplexResult>::ComplexResultwhere
B: for<'a> Buffer<'a, S, T>,
fn to_complex_b<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToComplexResult>::ComplexResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Complex, Freq>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Complex, Freq>
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Complex, Time>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Complex, Time>
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Real, Freq>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Real, Freq>
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Real, Time>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, Real, Time>
source§impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, RealOrComplex, TimeOrFreq>
impl<S, T, N, D> RededicateForceOps<DspVec<S, T, N, D>> for DspVec<S, T, RealOrComplex, TimeOrFreq>
source§fn rededicate_from_force(
origin: DspVec<S, T, N, D>
) -> DspVec<S, T, RealOrComplex, TimeOrFreq>
fn rededicate_from_force( origin: DspVec<S, T, N, D> ) -> DspVec<S, T, RealOrComplex, TimeOrFreq>
Other
a Self
without performing any checks.source§fn rededicate_with_runtime_data(
origin: DspVec<S, T, N, D>,
is_complex: bool,
domain: DataDomain
) -> DspVec<S, T, RealOrComplex, TimeOrFreq>
fn rededicate_with_runtime_data( origin: DspVec<S, T, N, D>, is_complex: bool, domain: DataDomain ) -> DspVec<S, T, RealOrComplex, TimeOrFreq>
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) -> DspVec<S, T, N, D>
fn rededicate_from(origin: O) -> DspVec<S, T, N, D>
source§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<DspVec<S, T, N, D>>,
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<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§fn resize_b<B>(&mut self, buffer: &mut B, len: usize) -> Result<(), ErrorReason>where
B: for<'a> Buffer<'a, S, T>,
fn resize_b<B>(&mut self, buffer: &mut B, len: usize) -> Result<(), ErrorReason>where
B: for<'a> Buffer<'a, S, T>,
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.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 DspVec<S, T, N, D>]
) -> Result<(), ErrorReason>
fn split_into( &self, targets: &mut [&mut DspVec<S, T, N, D>] ) -> Result<(), ErrorReason>
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>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>
source§fn statistics_split(
&self,
len: usize
) -> Result<ArrayVec<Statistics<Complex<T>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
fn statistics_split( &self, len: usize ) -> Result<ArrayVec<Statistics<Complex<T>>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
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>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>
source§fn statistics_split(
&self,
len: usize
) -> Result<ArrayVec<Statistics<T>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
fn statistics_split( &self, len: usize ) -> Result<ArrayVec<Statistics<T>, basic_dsp_vector::::vector_types::general::statistics::StatsVec::{constant#0}>, ErrorReason>
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
) -> Result<<DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult)>where
B: for<'a> Buffer<'a, S, T>,
fn plain_sifft<B>(
self,
buffer: &mut B
) -> Result<<DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <DspVec<S, T, N, D> as ToRealTimeResult>::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
) -> Result<<DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult)>where
B: for<'a> Buffer<'a, S, T>,
fn sifft<B>(
self,
buffer: &mut B
) -> Result<<DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <DspVec<S, T, N, D> as ToRealTimeResult>::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>
) -> Result<<DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult)>where
B: for<'a> Buffer<'a, S, T>,
fn windowed_sifft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> Result<<DspVec<S, T, N, D> as ToRealTimeResult>::RealTimeResult, (ErrorReason, <DspVec<S, T, N, D> as ToRealTimeResult>::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
) -> Result<<DspVec<S, T, N, D> as ToFreqResult>::FreqResult, (ErrorReason, <DspVec<S, T, N, D> as ToFreqResult>::FreqResult)>where
B: for<'a> Buffer<'a, S, T>,
fn plain_sfft<B>(
self,
buffer: &mut B
) -> Result<<DspVec<S, T, N, D> as ToFreqResult>::FreqResult, (ErrorReason, <DspVec<S, T, N, D> as ToFreqResult>::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
) -> Result<<DspVec<S, T, N, D> as ToFreqResult>::FreqResult, (ErrorReason, <DspVec<S, T, N, D> as ToFreqResult>::FreqResult)>where
B: for<'a> Buffer<'a, S, T>,
fn sfft<B>(
self,
buffer: &mut B
) -> Result<<DspVec<S, T, N, D> as ToFreqResult>::FreqResult, (ErrorReason, <DspVec<S, T, N, D> as ToFreqResult>::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>
) -> Result<<DspVec<S, T, N, D> as ToFreqResult>::FreqResult, (ErrorReason, <DspVec<S, T, N, D> as ToFreqResult>::FreqResult)>where
B: for<'a> Buffer<'a, S, T>,
fn windowed_sfft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> Result<<DspVec<S, T, N, D> as ToFreqResult>::FreqResult, (ErrorReason, <DspVec<S, T, N, D> as ToFreqResult>::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
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn plain_fft<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn fft<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn fft<B>(
self,
buffer: &mut B
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§fn windowed_fft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
fn windowed_fft<B>(
self,
buffer: &mut B,
window: &dyn WindowFunction<T>
) -> <DspVec<S, T, N, D> as ToFreqResult>::FreqResultwhere
B: for<'a> Buffer<'a, S, T>,
source§impl<S, T> ToComplexResult for DspVec<S, T, Real, Freq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToComplexResult for DspVec<S, T, Real, Freq>where
S: ToSlice<T>,
T: RealNumber,
type ComplexResult = DspVec<S, T, Complex, Freq>
source§impl<S, T> ToComplexResult for DspVec<S, T, Real, Time>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToComplexResult for DspVec<S, T, Real, Time>where
S: ToSlice<T>,
T: RealNumber,
type ComplexResult = DspVec<S, T, Complex, Time>
source§impl<S, T> ToComplexResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToComplexResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
type ComplexResult = DspVec<S, T, RealOrComplex, TimeOrFreq>
source§impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for [S; 2]
impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for [S; 2]
type Output = Matrix2xN<DspVec<S, T, Complex, Time>, S, T>
source§fn to_complex_time_mat(
self
) -> <[S; 2] as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
fn to_complex_time_mat( self ) -> <[S; 2] as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for [S; 3]
impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for [S; 3]
type Output = Matrix3xN<DspVec<S, T, Complex, Time>, S, T>
source§fn to_complex_time_mat(
self
) -> <[S; 3] as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
fn to_complex_time_mat( self ) -> <[S; 3] as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for [S; 4]
impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for [S; 4]
type Output = Matrix4xN<DspVec<S, T, Complex, Time>, S, T>
source§fn to_complex_time_mat(
self
) -> <[S; 4] as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
fn to_complex_time_mat( self ) -> <[S; 4] as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for Vec<S>
impl<T, S> ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T> for Vec<S>
type Output = MatrixMxN<DspVec<S, T, Complex, Time>, S, T>
source§fn to_complex_time_mat(
self
) -> <Vec<S> as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
fn to_complex_time_mat( self ) -> <Vec<S> as ToComplexTimeMatrix<DspVec<S, T, Complex, Time>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for [S; 2]
impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for [S; 2]
type Output = Matrix2xN<DspVec<S, T, RealOrComplex, TimeOrFreq>, S, T>
source§fn to_gen_dsp_mat(
self,
is_complex: bool,
domain: DataDomain
) -> <[S; 2] as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
fn to_gen_dsp_mat( self, is_complex: bool, domain: DataDomain ) -> <[S; 2] as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for [S; 3]
impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for [S; 3]
type Output = Matrix3xN<DspVec<S, T, RealOrComplex, TimeOrFreq>, S, T>
source§fn to_gen_dsp_mat(
self,
is_complex: bool,
domain: DataDomain
) -> <[S; 3] as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
fn to_gen_dsp_mat( self, is_complex: bool, domain: DataDomain ) -> <[S; 3] as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for [S; 4]
impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for [S; 4]
type Output = Matrix4xN<DspVec<S, T, RealOrComplex, TimeOrFreq>, S, T>
source§fn to_gen_dsp_mat(
self,
is_complex: bool,
domain: DataDomain
) -> <[S; 4] as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
fn to_gen_dsp_mat( self, is_complex: bool, domain: DataDomain ) -> <[S; 4] as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for Vec<S>
impl<T, S> ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T> for Vec<S>
type Output = MatrixMxN<DspVec<S, T, RealOrComplex, TimeOrFreq>, S, T>
source§fn to_gen_dsp_mat(
self,
is_complex: bool,
domain: DataDomain
) -> <Vec<S> as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
fn to_gen_dsp_mat( self, is_complex: bool, domain: DataDomain ) -> <Vec<S> as ToDspMatrix<DspVec<S, T, RealOrComplex, TimeOrFreq>, T>>::Output
delta
can be changed after construction with a call of set_delta
. Read moresource§impl<S, T> ToFreqResult for DspVec<S, T, Complex, Time>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToFreqResult for DspVec<S, T, Complex, Time>where
S: ToSlice<T>,
T: RealNumber,
type FreqResult = DspVec<S, T, Complex, Freq>
source§impl<S, T> ToFreqResult for DspVec<S, T, Real, Time>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToFreqResult for DspVec<S, T, Real, Time>where
S: ToSlice<T>,
T: RealNumber,
type FreqResult = DspVec<S, T, Complex, Freq>
source§impl<S, T> ToFreqResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToFreqResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
type FreqResult = DspVec<S, T, RealOrComplex, TimeOrFreq>
source§impl<S, T> ToRealResult for DspVec<S, T, Complex, Freq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToRealResult for DspVec<S, T, Complex, Freq>where
S: ToSlice<T>,
T: RealNumber,
type RealResult = DspVec<S, T, Real, Freq>
source§impl<S, T> ToRealResult for DspVec<S, T, Complex, Time>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToRealResult for DspVec<S, T, Complex, Time>where
S: ToSlice<T>,
T: RealNumber,
type RealResult = DspVec<S, T, Real, Time>
source§impl<S, T> ToRealResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToRealResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
type RealResult = DspVec<S, T, RealOrComplex, TimeOrFreq>
source§impl<S, T> ToRealTimeResult for DspVec<S, T, Complex, Freq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToRealTimeResult for DspVec<S, T, Complex, Freq>where
S: ToSlice<T>,
T: RealNumber,
type RealTimeResult = DspVec<S, T, Real, Time>
source§impl<S, T> ToRealTimeResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToRealTimeResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
type RealTimeResult = DspVec<S, T, RealOrComplex, TimeOrFreq>
source§impl<S, T> ToTimeResult for DspVec<S, T, Complex, Freq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToTimeResult for DspVec<S, T, Complex, Freq>where
S: ToSlice<T>,
T: RealNumber,
§type TimeResult = DspVec<S, T, Complex, Time>
type TimeResult = DspVec<S, T, Complex, Time>
source§impl<S, T> ToTimeResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
impl<S, T> ToTimeResult for DspVec<S, T, RealOrComplex, TimeOrFreq>where
S: ToSlice<T>,
T: RealNumber,
§type TimeResult = DspVec<S, T, RealOrComplex, TimeOrFreq>
type TimeResult = DspVec<S, T, RealOrComplex, TimeOrFreq>
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.