This is a collection if iterator extensions that make heavy use of number properties. Mostly extending on Range.
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 of steps, it steps by 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])); ```
There is no inclusive version of arange. Consider the following
```rust use iternumtools::arange;
let it = arange(0.0..=2.1, 0.5); ```
We would not expect 2.1 to ever be a value that the iterator will ever meet, but the range suggests it should be included. Therefore, no RangeInclusive implementation is provided.
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)); ```