Trait basic_dsp_vector::PowerOps[−][src]

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

    fn square(&mut self);

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

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

    fn ln(&mut self);

    fn exp(&mut self);

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

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

Roots, powers, exponentials and logarithms.

Required Methods

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]));

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[..]);

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[..]);

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[..]);

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);
}

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);
}

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);
}

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[..]);

Implementors