Trait basic_dsp::PowerOps

pub trait PowerOps<T>
where
    T: RealNumber,
{
    // Required methods
    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

fn sqrt(&mut self)

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

fn square(&mut self)

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

fn root(&mut self, degree: T)

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

fn powf(&mut self, exponent: T)

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

fn ln(&mut self)

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

fn exp(&mut self)

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

fn log(&mut self, base: T)

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

fn expf(&mut self, base: T)

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

impl<S, T, N, D> PowerOps<T> for DspVec<S, T, N, D>

where S: ToSliceMut<T>, T: RealNumber, N: NumberSpace, D: Domain,

impl<S, V, T> PowerOps<T> for Matrix2xN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + PowerOps<T>, T: RealNumber,

impl<S, V, T> PowerOps<T> for Matrix3xN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + PowerOps<T>, T: RealNumber,

impl<S, V, T> PowerOps<T> for Matrix4xN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + PowerOps<T>, T: RealNumber,

impl<S, V, T> PowerOps<T> for MatrixMxN<V, S, T>

where S: ToSlice<T>, V: Vector<T> + PowerOps<T>, T: RealNumber,