rft 0.1.0

FFT handling library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

mod linear;
pub use self::linear::Linear;

mod logarithmic;
pub use self::logarithmic::Logarithmic;

use {Precision};
use strided::{Strided, MutStrided, Stride, MutStride};

/// Trait to implement average algorithms.
pub trait Average {
	/// The additional arguments type.
	type Arguments;

	/// Computes the output size of the algorithm.
	fn size(args: &Self::Arguments) -> usize;

	/// Computes the average from the given arguments and input into the given
	/// ouotput.
	fn compute(args: &Self::Arguments,
	           input: Stride<Precision>,
	           mut output: MutStride<Precision>);
}

/// Get the size of the output for the given algorithm.
#[inline(always)]
pub fn size<A>(args: &A::Arguments) -> usize
	where A: Average
{
	A::size(args)
}

/// Compute the average of the given input and return a vector with the output.
#[inline(always)]
pub fn compute<A, I>(args: &A::Arguments, input: I) -> Vec<Precision>
	where A: Average,
	      I: Strided<Elem=Precision>
{
	let mut output = vec![0.0; A::size(args)];
	A::compute(args, input.as_stride(), output.as_stride_mut());

	output
}

/// Compute the average of the given input in the given output.
#[inline(always)]
pub fn compute_in<A, I, O>(args: &A::Arguments, input: I, mut output: O)
	where A: Average,
	      I: Strided<Elem=Precision>,
	      O: MutStrided<Elem=Precision>
{
	A::compute(args, input.as_stride(), output.as_stride_mut());
}

#[cfg(test)]
mod tests {
	use super::{Linear, Logarithmic};

	#[test]
	fn size() {
		assert_eq!(super::size::<Linear>(&3), 3);
		assert_eq!(super::size::<Logarithmic>(&(44100, 11, 1)), 11);
	}
}