[−][src]Trait basic_dsp::PowerOps

pub trait PowerOps<T> where
    T: RealNumber, {
    pub fn sqrt(&mut self);

    pub fn square(&mut self);

    pub fn root(&mut self, degree: T);

    pub fn powf(&mut self, exponent: T);

    pub fn ln(&mut self);

    pub fn exp(&mut self);

    pub fn log(&mut self, base: T);

    pub fn expf(&mut self, base: T);
}

Roots, powers, exponentials and logarithms.

Required methods

pub fn sqrt(&mut self)[src]

Gets the square root of all vector elements.

The sqrt of a negative number gives NaN and not a complex vector.

Example

use basic_dsp_vector::*;
let mut vector = vec!(1.0, 4.0, 9.0, 16.0, 25.0).to_real_time_vec();
vector.sqrt();
assert_eq!([1.0, 2.0, 3.0, 4.0, 5.0], vector[..]);
let mut vector = vec!(-1.0).to_real_time_vec();
vector.sqrt();
assert!(f64::is_nan(vector[0]));

pub fn square(&mut self)[src]

Squares all vector elements.

Example

use basic_dsp_vector::*;
let mut vector = vec!(1.0, 2.0, 3.0, 4.0, 5.0).to_real_time_vec();
vector.square();
assert_eq!([1.0, 4.0, 9.0, 16.0, 25.0], vector[..]);

pub fn root(&mut self, degree: T)[src]

Calculates the n-th root of every vector element.

If the result would be a complex number then the vector will contain a NaN instead. So the vector will never convert itself to a complex vector during this operation.

Example

use basic_dsp_vector::*;
let mut vector = vec!(1.0, 8.0, 27.0).to_real_time_vec();
vector.root(3.0);
assert_eq!([1.0, 2.0, 3.0], vector[..]);

pub fn powf(&mut self, exponent: T)[src]

Raises every vector element to a floating point power.

Example

use basic_dsp_vector::*;
let mut vector = vec!(1.0, 2.0, 3.0).to_real_time_vec();
vector.powf(3.0);
assert_eq!([1.0, 8.0, 27.0], vector[..]);

pub fn ln(&mut self)[src]

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

Example

use basic_dsp_vector::*;
let mut vector = vec!(2.718281828459045, 7.389056, 20.085537).to_real_time_vec();
vector.ln();
let actual = &vector[0..];
let expected = &[1.0, 2.0, 3.0];
assert_eq!(actual.len(), expected.len());
for i in 0..actual.len() {
       assert!(f64::abs(actual[i] - expected[i]) < 1e-4);
}

pub fn exp(&mut self)[src]

Calculates the natural exponential for every vector element.

Example

use basic_dsp_vector::*;
let mut vector = vec!(1.0, 2.0, 3.0).to_real_time_vec();
vector.exp();
let actual = &vector[0..];
let expected = &[2.718281828459045, 7.389056, 20.085537];
assert_eq!(actual.len(), expected.len());
for i in 0..actual.len() {
       assert!(f64::abs(actual[i] - expected[i]) < 1e-4);
}

pub fn log(&mut self, base: T)[src]

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

Example

use basic_dsp_vector::*;
let mut vector = vec!(10.0, 100.0, 1000.0).to_real_time_vec();
vector.log(10.0);
let actual = &vector[0..];
let expected = &[1.0, 2.0, 3.0];
assert_eq!(actual.len(), expected.len());
for i in 0..actual.len() {
       assert!(f64::abs(actual[i] - expected[i]) < 1e-4);
}

pub fn expf(&mut self, base: T)[src]

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

Example

use basic_dsp_vector::*;
let mut vector = vec!(1.0, 2.0, 3.0).to_real_time_vec();
vector.expf(10.0);
assert_eq!([10.0, 100.0, 1000.0], vector[..]);
Loading content...

Implementors

impl<S, T, N, D> PowerOps<T> for DspVec<S, T, N, D> where
    N: NumberSpace,
    T: RealNumber,
    S: ToSliceMut<T>,
    D: Domain, [src]

impl<S, V, T> PowerOps<T> for Matrix2xN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    V: Vector<T> + PowerOps<T>, [src]

impl<S, V, T> PowerOps<T> for Matrix3xN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    V: Vector<T> + PowerOps<T>, [src]

impl<S, V, T> PowerOps<T> for Matrix4xN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    V: Vector<T> + PowerOps<T>, [src]

impl<S, V, T> PowerOps<T> for MatrixMxN<V, S, T> where
    T: RealNumber,
    S: ToSlice<T>,
    V: Vector<T> + PowerOps<T>, [src]

Loading content...