# Crate iter_num_tools[−][src]

Expand description

`iter_num_tools` 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 iter_num_tools::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`

`GridSpace` extends on `LinSpace`.

```use iter_num_tools::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`

`Arange` is similar to `LinSpace`, but instead of a fixed amount of steps, it steps by a fixed amount.

```use iter_num_tools::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. Consider the following

```use iter_num_tools::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

`ArangeGrid` is the same as `GridSpace` but for `Arange` instead of `LinSpace`.

```use iter_num_tools::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([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`

`LogSpace` is similar to `LinSpace`, but instead of evenly spaced linear steps, it has evenly spaced logarithmic steps.

```use iter_num_tools::log_space;
use itertools::zip_eq;

// 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<f64> = vec![1.0, 10.0, 100.0, 1000.0];

assert!(zip_eq(it, 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<f64> = vec![1.0, 10.0, 100.0];

assert!(zip_eq(it, expected).all(|(x, y)| (x-y).abs() < 1e-10));```

## Functions

 arange Create a new iterator over the range, stepping by `step` each time This allows you to create simple float iterators arange_grid Creates a grid space over the range made up of fixed step intervals grid_space Creates a linear grid space over range with a fixed number of width and height steps lin_space Creates a linear space over range with a fixed number of steps log_space Creates a logarithmic space over range with a fixed number of steps

## Type Definitions

 Arange Iterator returned by `arange` ArangeGrid Iterator returned by `arange_grid` GridSpace Iterator returned by `grid_space` LinSpace Iterator returned by `lin_space` LogSpace Iterator returned by `log_space`