easing-fixed 0.2.0

easing iterators using fixed-point math
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

# `easing-fixed`: fixed-point easing iterators for rust

This is a fork of https://github.com/joliv/easing which uses [fixed-point](https://crates.io/crates/fixed) math instead. `no_std` compatible.

## Features added in fork
- smoothstep
- `at(t, start, distance)` and `at_normalized(t)` methods if you don't want iterators:

```rust
use easing_fixed::{Fix, ExpInOut};

let res = ExpInOut::at(Fix::from_num(0.5), Fix::from_num(10.), Fix::from_num(100)); // range is 10..=110, result is 60
let res = ExpInOut::at_normalized(Fix::from_num(0.75)); // range is 0..1, result is 0.984375
```
## Development

The test cases define an acceptable error margin (`ERROR_MARGIN_FAC`) and every test case stepping outside of that threshold gets its "is" and "ought" data written to `jupyter-tests/<name of test>-{is,ought}.json`. In there, you can use the supplied `tests.ipynb` notebook for a visualized representation of the failure:

![image](jupyter-tests/fail-example.png)

The JSON files get cleared out by `build.rs`. Sadly on every build, not just during tests, as cfg-gating for `test` is not possible there.

## (mostly preserved) original README below

Rust iterators are fantastic—why not use them for easing? Use like so:

```rust
use easing_fixed as easing;

let begin: f64 = 0;
let end:   f64 = 1000;
let steps: u64 = 10;

// In a for loop!
for x in easing::sin_in(begin, end, steps) {
    println!("Woo, I'm at x={}!", x);
}

// Mapping!
fn move_to(x: f64) {
    println!("Moving on up to {}", x);
}
easing::cubic_out(begin, end, steps).map(move_to);

// And other iterator stuff!
let xs: Vec<f64> = easing::exp_inout(begin, end, steps).collect(); // why would you do this
```

Available iterators are currently:

| function | in | out | in and out |
|----------|----|-----|-------|
| linear | `linear` | `linear` | `linear` |
| quadratic | `quad_in` | `quad_out` | `quad_inout` |
| cubic | `cubic_in` | `cubic_out` | `cubic_inout` |
| quartic | `quartic_in` | `quartic_out` | `quartic_inout` |
| sinusoidal | `sin_in` | `sin_out` | `sin_inout` |
| exponential | `exp_in` | `exp_out` | `exp_inout` |

Easing functions taken from [warrenm's AHEasing](https://github.com/warrenm/AHEasing).