iter-num-tools
This is a collection if iterator extensions that make heavy use of number properties. Mostly extending on Range.
LinSpace
LinSpace is an iterator over a range with a fixed number of values all evenly spaced.
use lin_space;
// Count from 1.0 up to and including 5.0, with 5 numbers counted in total
let it = lin_space;
assert!;
// Count from 0.0 up to and excluding 5.0, with 5 numbers counted in total
let it = lin_space;
assert!;
GridSpace
GridSpace extends on LinSpace.
use 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;
assert!;
// 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;
assert!;
Arange
Arange is similar to LinSpace, but instead of a fixed amount of steps, it steps by a fixed amount.
use arange;
let it = arange;
assert!;
Note
There is no inclusive version of arange. Consider the following
use arange;
let it = arange;
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
ArangeGrid is the same as GridSpace but for Arange instead of LinSpace.
use arange_grid;
// 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;
assert!;
// 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;
assert!;
LogSpace
LogSpace is similar to LinSpace, but instead of evenly spaced linear steps, it has evenly spaced logarithmic steps.
use log_space;
use zip_eq;
// From 1.0 up to and including 1000.0, taking 4 logarithmic steps
let it = log_space;
let expected: = ;
assert!;
// From 1.0 up to 1000.0, taking 3 logarithmic steps
let it = log_space;
let expected: = ;
assert!;
Alternatives
There is already a project called itertools-num
which has quite a few downloads but it
isn't optimised for speed or flexibility.
(try this benchmark for yourself: clone the repo and run cargo bench --bench "linspace" --all-features
)
LinSpace/linspace [1.0, 3.0] x100 (iter-num-tools)
time: [65.311 ns 65.579 ns 65.898 ns]
LinSpace/linspace [1.0, 3.0] x100 (std)
time: [67.545 ns 67.762 ns 68.047 ns]
LinSpace/linspace [1.0, 3.0] x100 (itertools-num)
time: [117.05 ns 117.59 ns 118.23 ns]
// first benchmark (fastest)
bench;
// second benchmark
bench;
// third benchmark (slowest)
bench;
It also does not provide any other utilities. Only linspace
(inclusive) and a 'Cumulative sum' iterator adaptor.