ndrustfft 0.6.0

N-dimensional FFT, real-to-complex FFT and real-to-real DCT
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# ndrustfft

## ndrustfft: *n*-dimensional complex-to-complex FFT, real-to-complex FFT and real-to-real DCT

This library is a wrapper for `RustFFT`, `RustDCT` and `RealFft`
that enables performing FFTs and DCTs of complex- and real-valued
data on *n*-dimensional arrays (ndarray).

ndrustfft provides Handler structs for FFT's and DCTs, which must be provided alongside
with the arrays to the respective functions (see below) .
The Handlers implement a process function, which is a wrapper around Rustfft's
process.
Transforms along the outermost axis are in general the fastest, while transforms along
other axis' will temporarily create copies of the input array.

### Parallel
The library ships all functions with a parallel version
which leverages the parallel iterators of the ndarray crate.

### Available transforms
#### Complex-to-complex
- `fft` : [`ndfft`], [`ndfft_par`]
- `ifft`: [`ndifft`],[`ndifft_par`]
#### Real-to-complex
- `fft_r2c` : [`ndfft_r2c`], [`ndfft_r2c_par`],
#### Complex-to-real
- `ifft_r2c`: [`ndifft_r2c`],[`ndifft_r2c_par`]
#### Real-to-real
- `dct1`: [`nddct1`],[`nddct1_par`]
- `dct2`: [`nddct2`],[`nddct2_par`]
- `dct3`: [`nddct3`],[`nddct3_par`]
- `dct4`: [`nddct4`],[`nddct4_par`]

### Example
2-Dimensional real-to-complex fft along first axis
```rust
use ndarray::{Array2, Dim, Ix};
use ndrustfft::{ndfft_r2c, Complex, R2cFftHandler};

let (nx, ny) = (6, 4);
let mut data = Array2::<f64>::zeros((nx, ny));
let mut vhat = Array2::<Complex<f64>>::zeros((nx / 2 + 1, ny));
for (i, v) in data.iter_mut().enumerate() {
    *v = i as f64;
}
let mut fft_handler = R2cFftHandler::<f64>::new(nx);
ndfft_r2c(
    &data.view(),
    &mut vhat.view_mut(),
    &mut fft_handler,
    0,
);
```

## Normalization
`RustFFT`, `RustDCT` and `RealFft`  do not normalise,
while this library applies normalization as scipy by default.
This means, inverse ffts are divided by a factor of `data.len()`,
and dcts are multiplied by two. It is possible to switch from the
default normalization to no normalization, or to apply a custom
normalization by using the normalization builder.

See: `examples/fft_norm`

## Features

- parallel: Enables parallel transform using `ndarrays` + `rayon` (enabled by default)
- avx: Enables `rustfft`'s avx feature (enabled by default)
- sse: Enables `rustfft`'s sse feature (enabled by default)
- neon: Enables `rustfft`'s neon feature (enabled by default)

## Documentation
[docs.rs](https://docs.rs/ndrustfft/)

## Versions
[Changelog](CHANGELOG.md)

License: MIT