https://github.com/coriolinus/lerp-rs
Linear interpolation and extrapolation over numeric types
https://github.com/coriolinus/lerp-rs
Last synced: over 1 year ago
JSON representation
Linear interpolation and extrapolation over numeric types
- Host: GitHub
- URL: https://github.com/coriolinus/lerp-rs
- Owner: coriolinus
- Created: 2016-08-05T11:01:24.000Z (almost 10 years ago)
- Default Branch: master
- Last Pushed: 2023-06-17T22:55:12.000Z (about 3 years ago)
- Last Synced: 2025-03-28T01:53:40.890Z (over 1 year ago)
- Language: Rust
- Homepage: https://coriolinus.github.io/lerp-rs/
- Size: 657 KB
- Stars: 5
- Watchers: 2
- Forks: 2
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
Awesome Lists containing this project
README
# Lerp
[](https://travis-ci.org/coriolinus/lerp-rs)
Linear interpolation and iteration, automatically implemented over most
float-compatible types.
Just need to know what's halfway between three and five?
```rust
use lerp::Lerp;
assert_eq!(3.0.lerp(5.0, 0.5), 4.0);
```
Want to iterate across some points in that range?
```rust
// bring the trait into scope
use lerp::LerpIter;
// iterate and produce four items evenly spaced between 3.0 and 5.0
// note that the default, open iterator does not include both endpoints
// this makes chaining lerping iterators simpler
let items: Vec<_> = 3.0_f64.lerp_iter(5.0, 4).collect();
assert_eq!(vec![3.0, 3.5, 4.0, 4.5], items);
// closed iterators return both ends
assert_eq!(vec![3.0, 5.0], 3.0.lerp_iter_closed(5.0, 2).collect::>());
```
Of course, the real benefit is that it's derivation is broad enough that it also
covers types such as `num::Complex`. If you have an array-processing library,
and the arrays are `T: Add + Mul`, it'll just
work for them as well.
## Deriving `Lerp`
As well as working for individual float values, the crate also provides a derive
macro, available with the `derive` feature, which will be able to generate an
implementation automatically.
This derive implementation will lerp each field of the struct independently
and assumes a generic implementation of Lerp over `Float` types. If any
of the fields is generic only over one of the float values (f32, f64) that
can be specified by the `#[lerp(f32)]` or `#[lerp(f64)]` attributes respectively.
If you would like for the lerp implementation to ignore a field (or if it does
not derive lerp) you can use the `#[lerp(skip)]` or `#[lerp(ignore)]` attributes
which will produce the value, untouched from the left value.
Not all types are supported in this derive macro. See [the github issue] for
discussion and more information.
```toml
[dependencies]
lerp = { version = "0.4", features = ["derive"] }
```
```rust
use lerp::Lerp;
#[derive(Lerp, PartialEq, Debug)]
struct Data {
a: f64,
b: f64
}
assert_eq!(
Data { a: 0.0, b: 1.0 }.lerp(Data { a: 1.0, b: 0.0 }, 0.5),
Data { a: 0.5, b: 0.5 }
);
```
More derive examples can be seen in the [tests]
## Usage
```toml
[dependencies]
lerp = "0.4"
```
## Documentation
Auto-built from Travis:
[the github issue]: https://github.com/coriolinus/lerp-rs/issues/6
[tests]: https://github.com/coriolinus/lerp-rs/tree/master/tests/derive.rs