This is a collection if iterator extensions that make heavy use of number properties. Mostly extending on Range. The most useful features are making range iterators over floats.
LinSpace is an iterator over a range with a fixed number of values all evenly spaced.
```rust use iternumtools::lin_space;
// Count from 1.0 up to and including 5.0, with 5 numbers counted in total let it = lin_space(1.0..=5.0, 5); assert!(it.eq(vec![1.0, 2.0, 3.0, 4.0, 5.0]));
// Count from 0.0 up to and excluding 5.0, with 5 numbers counted in total let it = lin_space(0.0..5.0, 5); assert!(it.eq(vec![0.0, 1.0, 2.0, 3.0, 4.0])); ```
GridSpace extends on LinSpace, up to 4 dimensions.
```rust use iternumtools::grid_space;
// count in 2 dimensions (excluding end points), // from 0.0 up to 1.0 in the x direction with 2 even steps, // and 0.0 up to 2.0 in the y direction with 4 even steps let it = grid_space((0.0, 0.0)..(1.0, 2.0), (2, 4)); assert!(it.eq(vec![ (0.0, 0.0), (0.0, 0.5), (0.0, 1.0), (0.0, 1.5), (0.5, 0.0), (0.5, 0.5), (0.5, 1.0), (0.5, 1.5), ]));
// count in 2 dimensions (including end points), // from 0.0 up to 1.0 in the x direction, // and 0.0 up to 2.0 in the y direction with 3 even steps in all directions let it = grid_space((0.0, 0.0)..=(1.0, 2.0), 3); assert!(it.eq(vec![ (0.0, 0.0), (0.0, 1.0), (0.0, 2.0), (0.5, 0.0), (0.5, 1.0), (0.5, 2.0), (1.0, 0.0), (1.0, 1.0), (1.0, 2.0), ])); ```
Arange is similar to LinSpace, but instead of a fixed amount or steps, it steps but a fixed amount.
```rust use iternumtools::arange;
let it = arange(0.0..2.0, 0.5); assert!(it.eq(vec![0.0, 0.5, 1.0, 1.5])); ```
Note, there is no inclusive version of arange
ArangeGrid is the same as GridSpace but for Arange instead of LinSpace.
```rust use iternumtools::arange_grid; use itertools::Itertools;
// count in 2 dimensions, // from 0.0 up to 1.0 in the x direction, // and 0.0 up to 2.0 in the y direction, // stepping by 0.5 each time let it = arange_grid((0.0, 0.0)..(1.0, 2.0), 0.5); assert!(it.eq(vec![ (0.0, 0.0), (0.0, 0.5), (0.0, 1.0), (0.0, 1.5), (0.5, 0.0), (0.5, 0.5), (0.5, 1.0), (0.5, 1.5), ]));
// count in 2 dimensions, // from 0.0 up to 1.0 in the x direction stepping by 0.5 each time, // and 0.0 up to 2.0 in the y direction stepping by 1.0 each time let it = arange_grid((0.0, 0.0)..(1.0, 2.0), (0.5, 1.0)); assert!(it.eq(vec![ (0.0, 0.0), (0.0, 1.0), (0.5, 0.0), (0.5, 1.0), ])); ```
LogSpace is similar to LinSpace, but instead of evenly spaced linear steps, it has evenly spaced logarithmic steps.
```rust use iternumtools::logspace; use itertools::zipeq;
// From 1.0 up to and including 1000.0, taking 4 logarithmic steps
let it = log_space(1.0..=1000.0, 4);
let expected: Vec
assert!(it.zip(expected).all(|(x, y)| (x-y).abs() < 1e-10));
// From 1.0 up to 1000.0, taking 3 logarithmic steps
let it = log_space(1.0..1000.0, 3);
let expected: Vec
assert!(it.zip(expected).all(|(x, y)| (x-y).abs() < 1e-10)); ```