Struct basic_dsp_vector::combined_ops::Identifier

pub struct Identifier<T, N, D> where
    T: RealNumber,
    D: Domain,
    N: NumberSpace,  { /* fields omitted */ }

An identifier is just a placeholder for a data type used to ensure already at compile time that operations are valid.

Trait Implementations

impl<T, N, D> GetMetaData<T, N, D> for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn get_meta_data(&self) -> TypeMetaData<T, N, D>

Gets a copy of the vector meta data. This can be used to create new types with the same meta data.

impl<T, N, D> OffsetOps<T> for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn offset(&mut self, offset: T)

Adds a scalar to each vector element.

impl<T, N, D> ScaleOps<T> for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn scale(&mut self, offset: T)

Multiplies the vector element with a scalar.

impl<T, N, D> OffsetOps<Complex<T>> for Identifier<T, N, D> where
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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

Adds a scalar to each vector element.

impl<T, N, D> ScaleOps<Complex<T>> for Identifier<T, N, D> where
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

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

Multiplies the vector element with a scalar.

impl<T, N, D> TrigOps for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn sin(&mut self)

Calculates the sine of each element in radians.

fn cos(&mut self)

Calculates the cosine of each element in radians.

fn tan(&mut self)

Calculates the tangent of each element in radians.

fn asin(&mut self)

Calculates the principal value of the inverse sine of each element in radians.

fn acos(&mut self)

Calculates the principal value of the inverse cosine of each element in radians.

fn atan(&mut self)

Calculates the principal value of the inverse tangent of each element in radians.

fn sinh(&mut self)

Calculates the hyperbolic sine each element in radians.

fn cosh(&mut self)

Calculates the hyperbolic cosine each element in radians.

fn tanh(&mut self)

Calculates the hyperbolic tangent each element in radians.

fn asinh(&mut self)

Calculates the principal value of the inverse hyperbolic sine of each element in radians.

fn acosh(&mut self)

Calculates the principal value of the inverse hyperbolic cosine of each element in radians.

fn atanh(&mut self)

Calculates the principal value of the inverse hyperbolic tangent of each element in radians.

impl<T, N, D> PowerOps<T> for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn sqrt(&mut self)

Gets the square root of all vector elements.

fn square(&mut self)

Squares all vector elements.

fn root(&mut self, degree: T)

Calculates the n-th root of every vector element.

fn powf(&mut self, exponent: T)

Raises every vector element to a floating point power.

fn ln(&mut self)

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

fn exp(&mut self)

Calculates the natural exponential for every vector element.

fn log(&mut self, base: T)

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

fn expf(&mut self, base: T)

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

impl<T, N, D> RealOps for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn abs(&mut self)

Gets the absolute value of all vector elements. # Example

impl<T, N, D> ComplexOps<T> for Identifier<T, N, D> where
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn multiply_complex_exponential(&mut self, a: T, b: T)

Multiplies each vector element with exp(j*(a*idx*self.delta() + b)) where a and b are arguments and idx is the index of the data points in the vector ranging from 0 to self.points() - 1. j is the imaginary number and exp the exponential function.

fn conj(&mut self)

Calculates the complex conjugate of the vector. # Example

impl<T, N, D> ElementaryOps<Identifier<T, N, D>, T, N, D> for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

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

Calculates the sum of self + summand. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

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

Calculates the difference of self - subtrahend. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

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

Calculates the product of self * factor. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

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

Calculates the quotient of self / summand. It consumes self and returns the result. # Failures TransRes may report the following ErrorReason members:

impl<T, N, D> IdentifierOps for Identifier<T, N, D> where
    T: RealNumber,
    N: NumberSpace,
    D: Domain, 

fn domain(&self) -> DataDomain

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

fn is_complex(&self) -> bool

Indicates whether the vector contains complex data. This also specifies the type of operations which are valid on this vector.

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

Copies data from another vector.

fn add_points(&mut self)

Adds its length to the vector elements # Example

fn sub_points(&mut self)

Subtracts its length from the vector elements # Example

fn div_points(&mut self)

divides the vector elements by its length Subtracts its length from the vector elements # Example

fn mul_points(&mut self)

Multiplies the vector elements with its length # Example

impl<T, N, D> RealToComplexTransformsOps<T> for Identifier<T, N, D> where
    Identifier<T, N, D>: ToComplexResult,
    <Identifier<T, N, D> as ToComplexResult>::ComplexResult: RededicateForceOps<Identifier<T, N, D>>,
    T: RealNumber,
    N: RealNumberSpace,
    D: Domain, 

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

Converts the real vector into a complex vector.

impl<T, N, D> ComplexToRealTransformsOps<T> for Identifier<T, N, D> where
    Identifier<T, N, D>: ToRealResult,
    <Identifier<T, N, D> as ToRealResult>::RealResult: RededicateForceOps<Identifier<T, N, D>>,
    T: RealNumber,
    N: ComplexNumberSpace,
    D: Domain, 

fn magnitude(self) -> Self::RealResult

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

fn magnitude_squared(self) -> Self::RealResult

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

fn to_real(self) -> Self::RealResult

Gets all real elements. # Example

fn to_imag(self) -> Self::RealResult

Gets all imag elements. # Example

fn phase(self) -> Self::RealResult

Gets the phase of all elements in [rad]. # Example

impl<T, N, D> Debug for Identifier<T, N, D> where
    T: RealNumber,
    D: Domain,
    N: NumberSpace, 

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

Formats the value using the given formatter.