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
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<T, N, D> PowerOps<T> for Identifier<T, N, D> where
T: RealNumber,
N: NumberSpace,
D: Domain,impl<S, T, N, D> PowerOps<T> for DspVec<S, T, N, D> where
S: ToSliceMut<T>,
T: RealNumber,
N: NumberSpace,
D: Domain,