Prepare 3.4.1.

Update simba requirement from 0.1.2 to 0.2.0

.dependabot/config.yml

@@ -0,0 +1,12 @@
+version: 1
+update_configs:
+  - package_manager: "rust:cargo"
+    directory: "."
+    update_schedule: "live"
+    target_branch: "master"
+    default_reviewers:
+      - "phaazon"
+    default_assignees:
+      - "phaazon"
+    default_labels:
+      - "dependency-update"

.github/workflows/ci.yaml

@@ -0,0 +1,54 @@
+name: CI
+on: [push, pull_request]
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Build
+        run: |
+          cargo build --verbose --all-features
+      - name: Test
+        run: |
+          cargo test --verbose --all-features
+
+  build-windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Build
+        run: |
+          cargo build --verbose --all-features
+      - name: Test
+        run: |
+          cargo test --verbose --all-features
+
+  build-macosx:
+    runs-on: macOS-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Rust requirements
+        run: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile=minimal
+      - name: Build
+        run: |
+          . ~/.cargo/env
+          cargo build --verbose --all-features
+      - name: Test
+        run: |
+          . ~/.cargo/env
+          cargo test --verbose --all-features
+
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Install dependencies
+        run: |
+          cargo install --force cargo-sync-readme
+          rustup component add rustfmt
+      - name: cargo sync-readme
+        run: |
+          cargo sync-readme -c
+      - name: rustfmt
+        run: cargo fmt -- --check

.travis.yml

@@ -1,24 +0,0 @@
-language: rust
-
-rust:
-  - stable
-  - beta
-  - nightly
-
-os:
-  - linux
-  - osx
-
-script:
-  - rustc --version
-  - cargo --version
-  - echo "Testing default crate configuration"
-  - cargo build --verbose
-  - cargo test --verbose
-  - cd examples && cargo check --verbose
-  - echo "Testing feature serialization"
-  - cargo build --verbose --features serialization
-  - cargo test --verbose --features serialization
-  - echo "Testing without std"
-  - cargo build --verbose --no-default-features
-  - cargo test --verbose --no-default-features

CHANGELOG.md

@@ -1,43 +1,185 @@
-## 0.2.3
+# Changelog
+
+<!-- vim-markdown-toc GFM -->
+
+* [3.4.1](#341)
+* [3.4](#34)
+* [3.3](#33)
+* [3.2](#32)
+* [3.1](#31)
+* [3.0](#30)
+  * [Major changes](#major-changes)
+  * [Patch changes](#patch-changes)
+* [2.2](#22)
+* [2.1.1](#211)
+* [2.1](#21)
+* [2.0.1](#201)
+* [2.0](#20)
+  * [Major changes](#major-changes-1)
+  * [Minor changes](#minor-changes)
+* [1.0](#10)
+  * [Major changes](#major-changes-2)
+  * [Minor changes](#minor-changes-1)
+  * [Patch changes](#patch-changes-1)
+* [0.2.3](#023)
+* [0.2.2](#022)
+* [0.2.1](#021)
+* [0.2](#02)
+* [0.1.1](#011)
+* [0.1](#01)
+
+<!-- vim-markdown-toc -->
+
+# 3.4.1
+
+> Sep 05th, 2020
+
+- Support of `simba-0.2`.
+- Support of `nalgebra-0.22`.
+
+# 3.4
+
+> Thu May 21st 2020
+
+- Add support for `float-cmp-0.7` and `float-cmp-0.8`. Because this uses a SemVer range, if you
+  already have a `Cargo.lock`, don’t forget to update `splines` with `cargo update --aggressive`.
+
+# 3.3
+
+> Thu Apr 10th 2020
+
+- Add support for `nalgebra-0.21`.
+
+# 3.2
+
+> Thu Mar 19th 2020
+
+- Add support for `nalgebra-0.20`.
+- Add support for `float-cmp-0.6`.
+
+# 3.1
+
+> Sat Jan 26th 2020
+
+- Add support for `nalgebra-0.19`.
+
+# 3.0
+
+> Tue Oct 22th 2019
+
+## Major changes
+
+- Sampling now requires the value of the key to be `Linear<T>` for `Interpolate<T>`. That is needed
+  to ease some interpolation mode (especially Bézier).
+
+## Patch changes
+
+- Fix Bézier interpolation when the next key is Bézier too.
+
+# 2.2
+
+> Mon Oct 17th 2019
+
+- Add `Interpolation::StrokeBezier`.
+
+# 2.1.1
+
+> Mon Oct 17th 2019
+
+- Licensing support in the crate.
+
+# 2.1
+
+> Mon Sep 30th 2019
+
+- Add `Spline::sample_with_key` and `Spline::clamped_sample_with_key`. Those methods allow one to
+  perform the regular `Spline::sample` and `Spline::clamped_sample` but also retreive the base
+  key that was used to perform the interpolation. The key can be inspected to get the base time,
+  interpolation, etc. The next key is also returned, if present.
+
+# 2.0.1
+
+> Tue Sep 24th 2019
+
+- Fix the cubic Bézier curve interpolation. The “output” tangent is now taken by mirroring the
+  next key’s tangent around its control point.
+
+# 2.0
+
+> Mon Sep 23rd 2019
+
+## Major changes
+
+- Add support for [Bézier curves](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+- Because of Bézier curves, the `Interpolation` type now has one more type variable to know how we
+  should interpolate with Bézier.
+
+## Minor changes
+
+- Add `Spline::get`, `Spline::get_mut` and `Spline::replace`.
+
+# 1.0
+
+> Sun Sep 22nd 2019
+
+## Major changes
+
+- Make `Spline::clamped_sample` failible via `Option` instead of panicking.
+- Add support for polymorphic sampling type.
+
+## Minor changes
+
+- Add the `std` feature (and hence support for `no_std`).
+- Add `impl-nalgebra` feature.
+- Add `impl-cgmath` feature.
+- Add support for adding keys to splines.
+- Add support for removing keys from splines.
+
+## Patch changes
+
+- Migrate to Rust 2018.
+- Documentation typo fixes.
+
+# 0.2.3
 
 > Sat 13th October 2018
 
-  - Add the `"impl-nalgebra"` feature gate. It gives access to some implementors for the `nalgebra`
-    crate.
-  - Enhance the documentation.
+- Add the `"impl-nalgebra"` feature gate. It gives access to some implementors for the `nalgebra`
+  crate.
+- Enhance the documentation.
 
-## 0.2.2
+# 0.2.2
 
 > Sun 30th September 2018
 
-  - Bump version numbers (`splines-0.2`) in examples.
-  - Fix several typos in the documentation.
+- Bump version numbers (`splines-0.2`) in examples.
+- Fix several typos in the documentation.
 
-## 0.2.1
+# 0.2.1
 
 > Thu 20th September 2018
 
-  - Enhance the features documentation.
+- Enhance the features documentation.
 
 # 0.2
 
 > Thu 6th September 2018
 
-  - Add the `"std"` feature gate, that can be used to compile with the standard library.
-  - Add the `"impl-cgmath"` feature gate in order to make optional, if wanted, the `cgmath`
-    dependency.
-  - Enhance the documentation.
+- Add the `"std"` feature gate, that can be used to compile with the standard library.
+- Add the `"impl-cgmath"` feature gate in order to make optional, if wanted, the `cgmath`
+  dependency.
+- Enhance the documentation.
 
-## 0.1.1
+# 0.1.1
 
 > Wed 8th August 2018
 
-  - Add a feature gate, `"serialization"`, that can be used to automatically derive `Serialize` and
-    `Deserialize` from the [serde](https://crates.io/crates/serde) crate.
-  - Enhance the documentation.
+- Add a feature gate, `"serialization"`, that can be used to automatically derive `Serialize` and
+  `Deserialize` from the [serde](https://crates.io/crates/serde) crate.
+- Enhance the documentation.
 
 # 0.1
 
 > Sunday 5th August 2018
 
-  - Initial revision.
+- Initial revision.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "splines"
-version = "0.2.3"
+version = "3.4.1"
 license = "BSD-3-Clause"
 authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
 description = "Spline interpolation made easy"
@@ -11,6 +11,8 @@ repository = "https://github.com/phaazon/splines"
 documentation = "https://docs.rs/splines"
 readme = "README.md"
 
+edition = "2018"
+
 [badges]
 travis-ci = { repository = "phaazon/splines", branch = "master" }
 is-it-maintained-issue-resolution = { repository = "phaazon/splines" }
@@ -18,24 +20,30 @@ is-it-maintained-open-issues = { repository = "phaazon/splines" }
 maintenance = { status = "actively-developed" }
 
 [features]
-default = ["std", "impl-cgmath"]
+default = ["std"]
+impl-cgmath = ["cgmath"]
+impl-nalgebra = ["nalgebra", "num-traits", "simba"]
 serialization = ["serde", "serde_derive"]
 std = []
-impl-cgmath = ["cgmath"]
-impl-nalgebra = ["nalgebra"]
 
-[dependencies.nalgebra]
-version = ">=0.14, <0.17"
-optional = true
+[dependencies]
+cgmath = { version = "0.17", optional = true }
+nalgebra = { version = ">=0.21, <0.23", optional = true }
+num-traits = { version = "0.2", optional = true }
+serde =  { version = "1", optional = true }
+serde_derive = { version = "1", optional = true }
+simba = { version = ">=0.1.2, <0.3", optional = true }
 
-[dependencies.cgmath]
-version = "0.16"
-optional = true
+[dev-dependencies]
+float-cmp = ">=0.6, < 0.9"
+serde_json = "1"
 
-[dependencies.serde]
-version = "1"
-optional = true
+[package.metadata.docs.rs]
+all-features = true
 
-[dependencies.serde_derive]
-version = "1"
-optional = true
+[[example]]
+name = "hello-world"
+
+[[example]]
+name = "serialization"
+required-features = ["serialization"]

LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2019, Dimitri Sabadie <dimitri.sabadie@gmail.com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Dimitri Sabadie <dimitri.sabadie@gmail.com> nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,26 +1,104 @@
-# splines
-
 This crate provides [splines](https://en.wikipedia.org/wiki/Spline_(mathematics)), mathematic curves
 defined piecewise through control keys a.k.a. knots.
 
 Feel free to dig in the [online documentation](https://docs.rs/splines) for further information.
 
-## A note on features
+<!-- cargo-sync-readme start -->
 
-This crate has features! Here’s a comprehensive list of what you can enable:
+# Spline interpolation made easy.
+
+This crate exposes splines for which each sections can be interpolated independently of each
+other – i.e. it’s possible to interpolate with a linear interpolator on one section and then
+switch to a cubic Hermite interpolator for the next section.
+
+Most of the crate consists of three types:
+
+  - [`Key`], which represents the control points by which the spline must pass.
+  - [`Interpolation`], the type of possible interpolation for each segment.
+  - [`Spline`], a spline from which you can *sample* points by interpolation.
+
+When adding control points, you add new sections. Two control points define a section – i.e.
+it’s not possible to define a spline without at least two control points. Every time you add a
+new control point, a new section is created. Each section is assigned an interpolation mode that
+is picked from its lower control point.
+
+# Quickly create splines
+
+```rust
+use splines::{Interpolation, Key, Spline};
+
+let start = Key::new(0., 0., Interpolation::Linear);
+let end = Key::new(1., 10., Interpolation::default());
+let spline = Spline::from_vec(vec![start, end]);
+```
+
+You will notice that we used `Interpolation::Linear` for the first key. The first key `start`’s
+interpolation will be used for the whole segment defined by those two keys. The `end`’s
+interpolation won’t be used. You can in theory use any [`Interpolation`] you want for the last
+key. We use the default one because we don’t care.
+
+# Interpolate values
+
+The whole purpose of splines is to interpolate discrete values to yield continuous ones. This is
+usually done with the [`Spline::sample`] method. This method expects the sampling parameter
+(often, this will be the time of your simulation) as argument and will yield an interpolated
+value.
+
+If you try to sample in out-of-bounds sampling parameter, you’ll get no value.
+
+```rust
+assert_eq!(spline.sample(0.), Some(0.));
+assert_eq!(spline.clamped_sample(1.), Some(10.));
+assert_eq!(spline.sample(1.1), None);
+```
+
+It’s possible that you want to get a value even if you’re out-of-bounds. This is especially
+important for simulations / animations. Feel free to use the `Spline::clamped_interpolation` for
+that purpose.
+
+```rust
+assert_eq!(spline.clamped_sample(-0.9), Some(0.)); // clamped to the first key
+assert_eq!(spline.clamped_sample(1.1), Some(10.)); // clamped to the last key
+```
+
+# Polymorphic sampling types
+
+[`Spline`] curves are parametered both by the carried value (being interpolated) but also the
+sampling type. It’s very typical to use `f32` or `f64` but really, you can in theory use any
+kind of type; that type must, however, implement a contract defined by a set of traits to
+implement. See [the documentation of this module](crate::interpolate) for further details.
+
+# Features and customization
+
+This crate was written with features baked in and hidden behind feature-gates. The idea is that
+the default configuration (i.e. you just add `"splines = …"` to your `Cargo.toml`) will always
+give you the minimal, core and raw concepts of what splines, keys / knots and interpolation
+modes are. However, you might want more. Instead of letting other people do the extra work to
+add implementations for very famous and useful traits – and do it in less efficient way, because
+they wouldn’t have access to the internals of this crate, it’s possible to enable features in an
+ad hoc way.
+
+This mechanism is not final and this is currently an experiment to see how people like it or
+not. It’s especially important to see how it copes with the documentation.
+
+So here’s a list of currently supported features and how to enable them:
 
   - **Serialization / deserialization.**
-    + This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
+    - This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
       types exported by this crate.
-    + Enable with the `"serialization"` feature.
+    - Enable with the `"serialization"` feature.
   - **[cgmath](https://crates.io/crates/cgmath) implementors.**
-    + Adds some useful implementations of `Interpolate` for some cgmath types.
-    + Enable with the `"impl-cgmath"` feature.
+    - Adds some useful implementations of `Interpolate` for some cgmath types.
+    - Enable with the `"impl-cgmath"` feature.
   - **[nalgebra](https://crates.io/crates/nalgebra) implementors.**
-    + Adds some useful implementations of `Interpolate` for some nalgebra types.
-    + Enable with the `"impl-nalgebra"` feature.
+    - Adds some useful implementations of `Interpolate` for some nalgebra types.
+    - Enable with the `"impl-nalgebra"` feature.
   - **Standard library / no standard library.**
-    + It’s possible to compile against the standard library or go on your own without it.
-    + Compiling with the standard library is enabled by default.
-    + Use `default-features = []` in your `Cargo.toml` to disable.
-    + Enable explicitly with the `"std"` feature.
+    - It’s possible to compile against the standard library or go on your own without it.
+    - Compiling with the standard library is enabled by default.
+    - Use `default-features = []` in your `Cargo.toml` to disable.
+    - Enable explicitly with the `"std"` feature.
+
+[`Interpolation`]: crate::interpolation::Interpolation
+
+<!-- cargo-sync-readme end -->

examples/01-hello-world/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "hello-world"
-version = "0.2.0"
-authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
-
-[dependencies]
-splines = "0.2"

examples/01-hello-world/src/main.rs

@@ -1,11 +0,0 @@
-extern crate splines;
-
-use splines::{Interpolation, Key, Spline};
-
-fn main() {
-  let keys = vec![Key::new(0., 0., Interpolation::default()), Key::new(5., 1., Interpolation::default())];
-  let spline = Spline::from_vec(keys);
-
-  println!("value at 0: {}", spline.clamped_sample(0.));
-  println!("value at 3: {}", spline.clamped_sample(3.));
-}

examples/02-serialization/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "serialization"
-version = "0.2.0"
-authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
-
-[dependencies]
-serde_json = "1"
-
-[dependencies.splines]
-version = "0.2"
-features = ["serialization"]

examples/Cargo.toml

@@ -1,9 +0,0 @@
-[workspace]
-
-members = [
-  "01-hello-world",
-  "02-serialization"
-]
-
-[patch.crates-io]
-splines = { path = ".." }

examples/hello-world.rs

@@ -0,0 +1,14 @@
+extern crate splines;
+
+use splines::{Interpolation, Key, Spline};
+
+fn main() {
+  let keys = vec![
+    Key::new(0., 0., Interpolation::default()),
+    Key::new(5., 1., Interpolation::default()),
+  ];
+  let spline = Spline::from_vec(keys);
+
+  println!("value at 0: {:?}", spline.clamped_sample(0.));
+  println!("value at 3: {:?}", spline.clamped_sample(3.));
+}

examples/serialization.rs

@@ -1,11 +1,12 @@
-#[macro_use] extern crate serde_json;
+#[macro_use]
+extern crate serde_json;
 extern crate splines;
 
-use serde_json::{Value, from_value};
+use serde_json::from_value;
 use splines::Spline;
 
 fn main() {
-  let value = json!{
+  let value = json! {
     [
       {
         "t": 0,
@@ -25,6 +26,6 @@ fn main() {
     ]
   };
 
-  let spline = from_value::<Spline<f32>>(value);
+  let spline = from_value::<Spline<f32, f32>>(value);
   println!("{:?}", spline);
 }

rustfmt.toml

@@ -0,0 +1,15 @@
+edition = "2018"
+
+fn_args_layout = "Tall"
+force_explicit_abi = true
+hard_tabs = false
+max_width = 100
+merge_derives = true
+newline_style = "Unix"
+remove_nested_parens = true
+reorder_imports = true
+reorder_modules = true
+tab_spaces = 2
+use_field_init_shorthand = true
+use_small_heuristics = "Default"
+use_try_shorthand = true

src/cgmath.rs

@@ -0,0 +1,92 @@
+use cgmath::{
+  BaseFloat, BaseNum, InnerSpace, Quaternion, Vector1, Vector2, Vector3, Vector4, VectorSpace,
+};
+
+use crate::interpolate::{
+  cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def, Additive, Interpolate, Linear, One,
+};
+
+macro_rules! impl_interpolate_vec {
+  ($($t:tt)*) => {
+    impl<T> Linear<T> for $($t)*<T> where T: BaseNum {
+      #[inline(always)]
+      fn outer_mul(self, t: T) -> Self {
+        self * t
+      }
+
+      #[inline(always)]
+      fn outer_div(self, t: T) -> Self {
+        self / t
+      }
+    }
+
+    impl<T> Interpolate<T> for $($t)*<T>
+    where Self: InnerSpace<Scalar = T>, T: Additive + BaseFloat + One {
+      #[inline(always)]
+      fn lerp(a: Self, b: Self, t: T) -> Self {
+        a.lerp(b, t)
+      }
+
+      #[inline(always)]
+      fn cubic_hermite(x: (Self, T), a: (Self, T), b: (Self, T), y: (Self, T), t: T) -> Self {
+        cubic_hermite_def(x, a, b, y, t)
+      }
+
+      #[inline(always)]
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
+        quadratic_bezier_def(a, u, b, t)
+      }
+
+      #[inline(always)]
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
+        cubic_bezier_def(a, u, v, b, t)
+      }
+    }
+  }
+}
+
+impl_interpolate_vec!(Vector1);
+impl_interpolate_vec!(Vector2);
+impl_interpolate_vec!(Vector3);
+impl_interpolate_vec!(Vector4);
+
+impl<T> Linear<T> for Quaternion<T>
+where
+  T: BaseFloat,
+{
+  #[inline(always)]
+  fn outer_mul(self, t: T) -> Self {
+    self * t
+  }
+
+  #[inline(always)]
+  fn outer_div(self, t: T) -> Self {
+    self / t
+  }
+}
+
+impl<T> Interpolate<T> for Quaternion<T>
+where
+  Self: InnerSpace<Scalar = T>,
+  T: Additive + BaseFloat + One,
+{
+  #[inline(always)]
+  fn lerp(a: Self, b: Self, t: T) -> Self {
+    a.nlerp(b, t)
+  }
+
+  #[inline(always)]
+  fn cubic_hermite(x: (Self, T), a: (Self, T), b: (Self, T), y: (Self, T), t: T) -> Self {
+    cubic_hermite_def(x, a, b, y, t)
+  }
+
+  #[inline(always)]
+  fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
+    quadratic_bezier_def(a, u, b, t)
+  }
+
+  #[inline(always)]
+  fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
+    cubic_bezier_def(a, u, v, b, t)
+  }
+}

src/interpolate.rs

@@ -0,0 +1,318 @@
+//! The [`Interpolate`] trait and associated symbols.
+//!
+//! The [`Interpolate`] trait is the central concept of the crate. It enables a spline to be
+//! sampled at by interpolating in between control points.
+//!
+//! In order for a type to be used in [`Spline<K, V>`], some properties must be met about the `K`
+//! type must implementing several traits:
+//!
+//!   - [`One`], giving a neutral element for the multiplication monoid.
+//!   - [`Additive`], making the type additive (i.e. one can add or subtract with it).
+//!   - [`Linear`], unlocking linear combinations, required for interpolating.
+//!   - [`Trigo`], a trait giving *π* and *cosine*, required for e.g. cosine interpolation.
+//!
+//! Feel free to have a look at current implementors for further help.
+//!
+//! > *Why doesn’t this crate use [num-traits] instead of
+//! > defining its own traits?*
+//!
+//! The reason for this is quite simple: this crate provides a `no_std` support, which is not
+//! currently available easily with [num-traits]. Also, if something changes in [num-traits] with
+//! those traits, it would make this whole crate unstable.
+//!
+//! [`Interpolate`]: crate::interpolate::Interpolate
+//! [`Spline<K, V>`]: crate::spline::Spline
+//! [`One`]: crate::interpolate::One
+//! [`Additive`]: crate::interpolate::Additive
+//! [`Linear`]: crate::interpolate::Linear
+//! [`Trigo`]: crate::interpolate::Trigo
+//! [num-traits]: https://crates.io/crates/num-traits
+
+#[cfg(not(feature = "std"))]
+use core::f32;
+#[cfg(not(feature = "std"))]
+use core::f64;
+#[cfg(not(feature = "std"))]
+use core::intrinsics::cosf32;
+#[cfg(not(feature = "std"))]
+use core::intrinsics::cosf64;
+#[cfg(not(feature = "std"))]
+use core::ops::{Add, Mul, Sub};
+#[cfg(feature = "std")]
+use std::f32;
+#[cfg(feature = "std")]
+use std::f64;
+#[cfg(feature = "std")]
+use std::ops::{Add, Mul, Sub};
+
+/// Keys that can be interpolated in between. Implementing this trait is required to perform
+/// sampling on splines.
+///
+/// `T` is the variable used to sample with. Typical implementations use [`f32`] or [`f64`], but
+/// you’re free to use the ones you like. Feel free to have a look at [`Spline::sample`] for
+/// instance to know which trait your type must implement to be usable.
+///
+/// [`Spline::sample`]: crate::spline::Spline::sample
+pub trait Interpolate<T>: Sized + Copy + Linear<T> {
+  /// Linear interpolation.
+  fn lerp(a: Self, b: Self, t: T) -> Self;
+
+  /// Cubic hermite interpolation.
+  ///
+  /// Default to [`lerp`].
+  ///
+  /// [`lerp`]: Interpolate::lerp
+  fn cubic_hermite(_: (Self, T), a: (Self, T), b: (Self, T), _: (Self, T), t: T) -> Self {
+    Self::lerp(a.0, b.0, t)
+  }
+
+  /// Quadratic Bézier interpolation.
+  fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self;
+
+  /// Cubic Bézier interpolation.
+  fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self;
+}
+
+/// Set of types that support additions and subtraction.
+///
+/// The [`Copy`] trait is also a supertrait as it’s likely to be used everywhere.
+pub trait Additive: Copy + Add<Self, Output = Self> + Sub<Self, Output = Self> {}
+
+impl<T> Additive for T where T: Copy + Add<Self, Output = Self> + Sub<Self, Output = Self> {}
+
+/// Set of additive types that support outer multiplication and division, making them linear.
+pub trait Linear<T>: Additive {
+  /// Apply an outer multiplication law.
+  fn outer_mul(self, t: T) -> Self;
+
+  /// Apply an outer division law.
+  fn outer_div(self, t: T) -> Self;
+}
+
+macro_rules! impl_linear_simple {
+  ($t:ty) => {
+    impl Linear<$t> for $t {
+      fn outer_mul(self, t: $t) -> Self {
+        self * t
+      }
+
+      /// Apply an outer division law.
+      fn outer_div(self, t: $t) -> Self {
+        self / t
+      }
+    }
+  };
+}
+
+impl_linear_simple!(f32);
+impl_linear_simple!(f64);
+
+macro_rules! impl_linear_cast {
+  ($t:ty, $q:ty) => {
+    impl Linear<$t> for $q {
+      fn outer_mul(self, t: $t) -> Self {
+        self * t as $q
+      }
+
+      /// Apply an outer division law.
+      fn outer_div(self, t: $t) -> Self {
+        self / t as $q
+      }
+    }
+  };
+}
+
+impl_linear_cast!(f32, f64);
+impl_linear_cast!(f64, f32);
+
+/// Types with a neutral element for multiplication.
+pub trait One {
+  /// The neutral element for the multiplicative monoid — typically called `1`.
+  fn one() -> Self;
+}
+
+macro_rules! impl_one_float {
+  ($t:ty) => {
+    impl One for $t {
+      #[inline(always)]
+      fn one() -> Self {
+        1.
+      }
+    }
+  };
+}
+
+impl_one_float!(f32);
+impl_one_float!(f64);
+
+/// Types with a sane definition of π and cosine.
+pub trait Trigo {
+  /// π.
+  fn pi() -> Self;
+
+  /// Cosine of the argument.
+  fn cos(self) -> Self;
+}
+
+impl Trigo for f32 {
+  #[inline(always)]
+  fn pi() -> Self {
+    f32::consts::PI
+  }
+
+  #[inline(always)]
+  fn cos(self) -> Self {
+    #[cfg(feature = "std")]
+    {
+      self.cos()
+    }
+
+    #[cfg(not(feature = "std"))]
+    {
+      unsafe { cosf32(self) }
+    }
+  }
+}
+
+impl Trigo for f64 {
+  #[inline(always)]
+  fn pi() -> Self {
+    f64::consts::PI
+  }
+
+  #[inline(always)]
+  fn cos(self) -> Self {
+    #[cfg(feature = "std")]
+    {
+      self.cos()
+    }
+
+    #[cfg(not(feature = "std"))]
+    {
+      unsafe { cosf64(self) }
+    }
+  }
+}
+
+/// Default implementation of [`Interpolate::cubic_hermite`].
+///
+/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
+pub fn cubic_hermite_def<V, T>(x: (V, T), a: (V, T), b: (V, T), y: (V, T), t: T) -> V
+where
+  V: Linear<T>,
+  T: Additive + Mul<T, Output = T> + One,
+{
+  // some stupid generic constants, because Rust doesn’t have polymorphic literals…
+  let one_t = T::one();
+  let two_t = one_t + one_t; // lolololol
+  let three_t = two_t + one_t; // megalol
+
+  // sampler stuff
+  let t2 = t * t;
+  let t3 = t2 * t;
+  let two_t3 = t3 * two_t;
+  let three_t2 = t2 * three_t;
+
+  // tangents
+  let m0 = (b.0 - x.0).outer_div(b.1 - x.1);
+  let m1 = (y.0 - a.0).outer_div(y.1 - a.1);
+
+  a.0.outer_mul(two_t3 - three_t2 + one_t)
+    + m0.outer_mul(t3 - t2 * two_t + t)
+    + b.0.outer_mul(three_t2 - two_t3)
+    + m1.outer_mul(t3 - t2)
+}
+
+/// Default implementation of [`Interpolate::quadratic_bezier`].
+///
+/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
+pub fn quadratic_bezier_def<V, T>(a: V, u: V, b: V, t: T) -> V
+where
+  V: Linear<T>,
+  T: Additive + Mul<T, Output = T> + One,
+{
+  let one_t = T::one() - t;
+  let one_t_2 = one_t * one_t;
+  u + (a - u).outer_mul(one_t_2) + (b - u).outer_mul(t * t)
+}
+
+/// Default implementation of [`Interpolate::cubic_bezier`].
+///
+/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
+pub fn cubic_bezier_def<V, T>(a: V, u: V, v: V, b: V, t: T) -> V
+where
+  V: Linear<T>,
+  T: Additive + Mul<T, Output = T> + One,
+{
+  let one_t = T::one() - t;
+  let one_t_2 = one_t * one_t;
+  let one_t_3 = one_t_2 * one_t;
+  let three = T::one() + T::one() + T::one();
+
+  a.outer_mul(one_t_3)
+    + u.outer_mul(three * one_t_2 * t)
+    + v.outer_mul(three * one_t * t * t)
+    + b.outer_mul(t * t * t)
+}
+
+macro_rules! impl_interpolate_simple {
+  ($t:ty) => {
+    impl Interpolate<$t> for $t {
+      fn lerp(a: Self, b: Self, t: $t) -> Self {
+        a * (1. - t) + b * t
+      }
+
+      fn cubic_hermite(x: (Self, $t), a: (Self, $t), b: (Self, $t), y: (Self, $t), t: $t) -> Self {
+        cubic_hermite_def(x, a, b, y, t)
+      }
+
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
+        quadratic_bezier_def(a, u, b, t)
+      }
+
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
+        cubic_bezier_def(a, u, v, b, t)
+      }
+    }
+  };
+}
+
+impl_interpolate_simple!(f32);
+impl_interpolate_simple!(f64);
+
+macro_rules! impl_interpolate_via {
+  ($t:ty, $v:ty) => {
+    impl Interpolate<$t> for $v {
+      fn lerp(a: Self, b: Self, t: $t) -> Self {
+        a * (1. - t as $v) + b * t as $v
+      }
+
+      fn cubic_hermite(
+        (x, xt): (Self, $t),
+        (a, at): (Self, $t),
+        (b, bt): (Self, $t),
+        (y, yt): (Self, $t),
+        t: $t,
+      ) -> Self {
+        cubic_hermite_def(
+          (x, xt as $v),
+          (a, at as $v),
+          (b, bt as $v),
+          (y, yt as $v),
+          t as $v,
+        )
+      }
+
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
+        quadratic_bezier_def(a, u, b, t as $v)
+      }
+
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
+        cubic_bezier_def(a, u, v, b, t as $v)
+      }
+    }
+  };
+}
+
+impl_interpolate_via!(f32, f64);
+impl_interpolate_via!(f64, f32);

src/interpolation.rs

@@ -0,0 +1,65 @@
+//! Available interpolation modes.
+
+#[cfg(feature = "serialization")]
+use serde_derive::{Deserialize, Serialize};
+
+/// Available kind of interpolations.
+///
+/// Feel free to visit each variant for more documentation.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
+pub enum Interpolation<T, V> {
+  /// Hold a [`Key`] until the sampling value passes the normalized step threshold, in which
+  /// case the next key is used.
+  ///
+  /// > Note: if you set the threshold to `0.5`, the first key will be used until half the time
+  /// > between the two keys; the second key will be in used afterwards. If you set it to `1.0`, the
+  /// > first key will be kept until the next key. Set it to `0.` and the first key will never be
+  /// > used.
+  ///
+  /// [`Key`]: crate::key::Key
+  Step(T),
+  /// Linear interpolation between a key and the next one.
+  Linear,
+  /// Cosine interpolation between a key and the next one.
+  Cosine,
+  /// Catmull-Rom interpolation, performing a cubic Hermite interpolation using four keys.
+  CatmullRom,
+  /// Bézier interpolation.
+  ///
+  /// A control point that uses such an interpolation is associated with an extra point. The segmant
+  /// connecting both is called the _tangent_ of this point. The part of the spline defined between
+  /// this control point and the next one will be interpolated across with Bézier interpolation. Two
+  /// cases are possible:
+  ///
+  /// - The next control point also has a Bézier interpolation mode. In this case, its tangent is
+  ///   used for the interpolation process. This is called _cubic Bézier interpolation_ and it
+  ///   kicks ass.
+  /// - The next control point doesn’t have a Bézier interpolation mode set. In this case, the
+  ///   tangent used for the next control point is defined as the segment connecting that control
+  ///   point and the current control point’s associated point. This is called _quadratic Bézer
+  ///   interpolation_ and it kicks ass too, but a bit less than cubic.
+  Bezier(V),
+  /// A special Bézier interpolation using an _input tangent_ and an _output tangent_.
+  ///
+  /// With this kind of interpolation, a control point has an input tangent, which has the same role
+  /// as the one defined by [`Interpolation::Bezier`], and an output tangent, which has the same
+  /// role defined by the next key’s [`Interpolation::Bezier`] if present, normally.
+  ///
+  /// What it means is that instead of setting the output tangent as the next key’s Bézier tangent,
+  /// this interpolation mode allows you to manually set the output tangent. That will yield more
+  /// control on the tangents but might generate discontinuities. Use with care.
+  ///
+  /// Stroke Bézier interpolation is always a cubic Bézier interpolation by default.
+  StrokeBezier(V, V),
+  #[doc(hidden)]
+  __NonExhaustive,
+}
+
+impl<T, V> Default for Interpolation<T, V> {
+  /// [`Interpolation::Linear`] is the default.
+  fn default() -> Self {
+    Interpolation::Linear
+  }
+}

src/iter.rs

@@ -0,0 +1,44 @@
+//! Spline [`Iterator`], in a nutshell.
+//!
+//! You can iterate over a [`Spline<K, V>`]’s keys with the [`IntoIterator`] trait on
+//! `&Spline<K, V>`. This gives you iterated [`Key<K, V>`] keys.
+//!
+//! [`Spline<K, V>`]: crate::spline::Spline
+//! [`Key<K, V>`]: crate::key::Key
+
+use crate::{Key, Spline};
+
+/// Iterator over spline keys.
+///
+/// This iterator type is guaranteed to iterate over sorted keys.
+pub struct Iter<'a, T, V>
+where
+  T: 'a,
+  V: 'a,
+{
+  spline: &'a Spline<T, V>,
+  i: usize,
+}
+
+impl<'a, T, V> Iterator for Iter<'a, T, V> {
+  type Item = &'a Key<T, V>;
+
+  fn next(&mut self) -> Option<Self::Item> {
+    let r = self.spline.0.get(self.i);
+
+    if let Some(_) = r {
+      self.i += 1;
+    }
+
+    r
+  }
+}
+
+impl<'a, T, V> IntoIterator for &'a Spline<T, V> {
+  type Item = &'a Key<T, V>;
+  type IntoIter = Iter<'a, T, V>;
+
+  fn into_iter(self) -> Self::IntoIter {
+    Iter { spline: self, i: 0 }
+  }
+}

src/key.rs

@@ -0,0 +1,42 @@
+//! Spline control points.
+//!
+//! A control point associates to a “sampling value” (a.k.a. time) a carriede value that can be
+//! interpolated along the curve made by the control points.
+//!
+//! Splines constructed with this crate have the property that it’s possible to change the
+//! interpolation mode on a key-based way, allowing you to implement and encode complex curves.
+
+#[cfg(feature = "serialization")]
+use serde_derive::{Deserialize, Serialize};
+
+use crate::interpolation::Interpolation;
+
+/// A spline control point.
+///
+/// This type associates a value at a given interpolation parameter value. It also contains an
+/// interpolation mode used to determine how to interpolate values on the segment defined by this
+/// key and the next one – if existing. Have a look at [`Interpolation`] for further details.
+///
+/// [`Interpolation`]: crate::interpolation::Interpolation
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
+pub struct Key<T, V> {
+  /// Interpolation parameter at which the [`Key`] should be reached.
+  pub t: T,
+  /// Carried value.
+  pub value: V,
+  /// Interpolation mode.
+  pub interpolation: Interpolation<T, V>,
+}
+
+impl<T, V> Key<T, V> {
+  /// Create a new key.
+  pub fn new(t: T, value: V, interpolation: Interpolation<T, V>) -> Self {
+    Key {
+      t,
+      value,
+      interpolation,
+    }
+  }
+}

src/lib.rs

@@ -33,11 +33,11 @@
 //! # Interpolate values
 //!
 //! The whole purpose of splines is to interpolate discrete values to yield continuous ones. This is
-//! usually done with the `Spline::sample` method. This method expects the interpolation parameter
+//! usually done with the [`Spline::sample`] method. This method expects the sampling parameter
 //! (often, this will be the time of your simulation) as argument and will yield an interpolated
 //! value.
 //!
-//! If you try to sample in out-of-bounds interpolation parameter, you’ll get no value.
+//! If you try to sample in out-of-bounds sampling parameter, you’ll get no value.
 //!
 //! ```
 //! # use splines::{Interpolation, Key, Spline};
@@ -45,7 +45,7 @@
 //! # let end = Key::new(1., 10., Interpolation::Linear);
 //! # let spline = Spline::from_vec(vec![start, end]);
 //! assert_eq!(spline.sample(0.), Some(0.));
-//! assert_eq!(spline.clamped_sample(1.), 10.);
+//! assert_eq!(spline.clamped_sample(1.), Some(10.));
 //! assert_eq!(spline.sample(1.1), None);
 //! ```
 //!
@@ -58,13 +58,21 @@
 //! # let start = Key::new(0., 0., Interpolation::Linear);
 //! # let end = Key::new(1., 10., Interpolation::Linear);
 //! # let spline = Spline::from_vec(vec![start, end]);
-//! assert_eq!(spline.clamped_sample(-0.9), 0.); // clamped to the first key
-//! assert_eq!(spline.clamped_sample(1.1), 10.); // clamped to the last key
+//! assert_eq!(spline.clamped_sample(-0.9), Some(0.)); // clamped to the first key
+//! assert_eq!(spline.clamped_sample(1.1), Some(10.)); // clamped to the last key
 //! ```
+//!
+//! # Polymorphic sampling types
+//!
+//! [`Spline`] curves are parametered both by the carried value (being interpolated) but also the
+//! sampling type. It’s very typical to use `f32` or `f64` but really, you can in theory use any
+//! kind of type; that type must, however, implement a contract defined by a set of traits to
+//! implement. See [the documentation of this module](crate::interpolate) for further details.
+//!
 //! # Features and customization
 //!
 //! This crate was written with features baked in and hidden behind feature-gates. The idea is that
-//! the default configuration (i.e. you just add `"spline = …"` to your `Cargo.toml`) will always
+//! the default configuration (i.e. you just add `"splines = …"` to your `Cargo.toml`) will always
 //! give you the minimal, core and raw concepts of what splines, keys / knots and interpolation
 //! modes are. However, you might want more. Instead of letting other people do the extra work to
 //! add implementations for very famous and useful traits – and do it in less efficient way, because
@@ -77,432 +85,41 @@
 //! So here’s a list of currently supported features and how to enable them:
 //!
 //!   - **Serialization / deserialization.**
-//!     + This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
+//!     - This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
 //!       types exported by this crate.
-//!     + Enable with the `"serialization"` feature.
+//!     - Enable with the `"serialization"` feature.
 //!   - **[cgmath](https://crates.io/crates/cgmath) implementors.**
-//!     + Adds some useful implementations of `Interpolate` for some cgmath types.
-//!     + Enable with the `"impl-cgmath"` feature.
+//!     - Adds some useful implementations of `Interpolate` for some cgmath types.
+//!     - Enable with the `"impl-cgmath"` feature.
 //!   - **[nalgebra](https://crates.io/crates/nalgebra) implementors.**
-//!     + Adds some useful implementations of `Interpolate` for some nalgebra types.
-//!     + Enable with the `"impl-nalgebra"` feature.
+//!     - Adds some useful implementations of `Interpolate` for some nalgebra types.
+//!     - Enable with the `"impl-nalgebra"` feature.
 //!   - **Standard library / no standard library.**
-//!     + It’s possible to compile against the standard library or go on your own without it.
-//!     + Compiling with the standard library is enabled by default.
-//!     + Use `default-features = []` in your `Cargo.toml` to disable.
-//!     + Enable explicitly with the `"std"` feature.
+//!     - It’s possible to compile against the standard library or go on your own without it.
+//!     - Compiling with the standard library is enabled by default.
+//!     - Use `default-features = []` in your `Cargo.toml` to disable.
+//!     - Enable explicitly with the `"std"` feature.
+//!
+//! [`Interpolation`]: crate::interpolation::Interpolation
 
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]
 #![cfg_attr(not(feature = "std"), feature(core_intrinsics))]
 
-// on no_std, we also need the alloc crate for Vec
-#[cfg(not(feature = "std"))] extern crate alloc;
-
-#[cfg(feature = "impl-cgmath")] extern crate cgmath;
-
-#[cfg(feature = "impl-nalgebra")] extern crate nalgebra;
-
-#[cfg(feature = "serialization")] extern crate serde;
-#[cfg(feature = "serialization")] #[macro_use] extern crate serde_derive;
-
-#[cfg(feature = "impl-cgmath")] use cgmath::{InnerSpace, Quaternion, Vector2, Vector3, Vector4};
-
-#[cfg(feature = "impl-nalgebra")] use nalgebra as na;
-#[cfg(feature = "impl-nalgebra")] use nalgebra::core::{DimName, DefaultAllocator, Scalar};
-#[cfg(feature = "impl-nalgebra")] use nalgebra::core::allocator::Allocator;
-
-#[cfg(feature = "std")] use std::cmp::Ordering;
-#[cfg(feature = "std")] use std::f32::consts;
-#[cfg(feature = "std")] use std::ops::{Add, Div, Mul, Sub};
-
-#[cfg(not(feature = "std"))] use alloc::vec::Vec;
-#[cfg(not(feature = "std"))] use core::cmp::Ordering;
-#[cfg(not(feature = "std"))] use core::f32::consts;
-#[cfg(not(feature = "std"))] use core::ops::{Add, Div, Mul, Sub};
-
-/// A spline control point.
-///
-/// This type associates a value at a given interpolation parameter value. It also contains an
-/// interpolation hint used to determine how to interpolate values on the segment defined by this
-/// key and the next one – if existing.
-#[derive(Copy, Clone, Debug)]
-#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
-#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
-pub struct Key<T> {
-  /// Interpolation parameter at which the [`Key`] should be reached.
-  pub t: f32,
-  /// Held value.
-  pub value: T,
-  /// Interpolation mode.
-  pub interpolation: Interpolation
-}
-
-impl<T> Key<T> {
-  /// Create a new key.
-  pub fn new(t: f32, value: T, interpolation: Interpolation) -> Self {
-    Key {
-      t: t,
-      value: value,
-      interpolation: interpolation
-    }
-  }
-}
-
-/// Interpolation mode.
-#[derive(Copy, Clone, Debug)]
-#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
-#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
-pub enum Interpolation {
-  /// Hold a [`Key`] until the time passes the normalized step threshold, in which case the next
-  /// key is used.
-  ///
-  /// *Note: if you set the threshold to `0.5`, the first key will be used until the time is half
-  /// between the two keys; the second key will be in used afterwards. If you set it to `1.0`, the
-  /// first key will be kept until the next key. Set it to `0.` and the first key will never be
-  /// used.*
-  Step(f32),
-  /// Linear interpolation between a key and the next one.
-  Linear,
-  /// Cosine interpolation between a key and the next one.
-  Cosine,
-  /// Catmull-Rom interpolation.
-  CatmullRom
-}
-
-impl Default for Interpolation {
-  /// `Interpolation::Linear` is the default.
-  fn default() -> Self {
-    Interpolation::Linear
-  }
-}
-
-/// Spline curve used to provide interpolation between control points (keys).
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
-pub struct Spline<T>(Vec<Key<T>>);
-
-impl<T> Spline<T> {
-  /// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended
-  /// to provide ascending sorted ones (for performance purposes).
-  pub fn from_vec(mut keys: Vec<Key<T>>) -> Self {
-    keys.sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less));
-
-    Spline(keys)
-  }
-
-  /// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
-  /// sorted.
-  ///
-  /// # Note on iterators
-  ///
-  /// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should
-  /// use `Spline::from_vec` if you are passing a `Vec<_>`. This will remove dynamic allocations.
-  pub fn from_iter<I>(iter: I) -> Self where I: Iterator<Item = Key<T>> {
-    Self::from_vec(iter.collect())
-  }
-
-  /// Retrieve the keys of a spline.
-  pub fn keys(&self) -> &[Key<T>] {
-    &self.0
-  }
-
-  /// Sample a spline at a given time.
-  ///
-  /// The current implementation, based on immutability, cannot perform in constant time. This means
-  /// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
-  /// performance by using a slightly different spline type. If you are interested by this feature,
-  /// an implementation for a dedicated type is foreseen yet not started yet.
-  ///
-  /// # Return
-  ///
-  /// `None` if you try to sample a value at a time that has no key associated with. That can also
-  /// happen if you try to sample between two keys with a specific interpolation mode that make the
-  /// sampling impossible. For instance, `Interpolate::CatmullRom` requires *four* keys. If you’re
-  /// near the beginning of the spline or its end, ensure you have enough keys around to make the
-  /// sampling.
-  pub fn sample(&self, t: f32) -> Option<T> where T: Interpolate {
-    let keys = &self.0;
-    let i = search_lower_cp(keys, t)?;
-    let cp0 = &keys[i];
-
-    match cp0.interpolation {
-      Interpolation::Step(threshold) => {
-        let cp1 = &keys[i+1];
-        let nt = normalize_time(t, cp0, cp1);
-        Some(if nt < threshold { cp0.value } else { cp1.value })
-      },
-      Interpolation::Linear => {
-        let cp1 = &keys[i+1];
-        let nt = normalize_time(t, cp0, cp1);
-
-        Some(Interpolate::lerp(cp0.value, cp1.value, nt))
-      },
-      Interpolation::Cosine => {
-        let cp1 = &keys[i+1];
-        let nt = normalize_time(t, cp0, cp1);
-        let cos_nt = {
-          #[cfg(feature = "std")]
-          {
-            (1. - f32::cos(nt * consts::PI)) * 0.5
-          }
-
-          #[cfg(not(feature = "std"))]
-          {
-            use core::intrinsics::cosf32;
-            unsafe { (1. - cosf32(nt * consts::PI)) * 0.5 }
-          }
-        };
-
-        Some(Interpolate::lerp(cp0.value, cp1.value, cos_nt))
-      },
-      Interpolation::CatmullRom => {
-        // We need at least four points for Catmull Rom; ensure we have them, otherwise, return
-        // None.
-        if i == 0 || i >= keys.len() - 2 {
-          None
-        } else {
-          let cp1 = &keys[i+1];
-          let cpm0 = &keys[i-1];
-          let cpm1 = &keys[i+2];
-          let nt = normalize_time(t, cp0, cp1);
-
-          Some(Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt))
-        }
-      }
-    }
-  }
-
-  /// Sample a spline at a given time with clamping.
-  ///
-  /// # Return
-  ///
-  /// If you sample before the first key or after the last one, return the first key or the last
-  /// one, respectively. Otherwise, behave the same way as `Spline::sample`.
-  ///
-  /// # Panic
-  ///
-  /// This function panics if you have no key.
-  pub fn clamped_sample(&self, t: f32) -> T where T: Interpolate {
-    let first = self.0.first().unwrap();
-    let last = self.0.last().unwrap();
-
-    if t <= first.t {
-      return first.value;
-    } else if t >= last.t {
-      return last.value;
-    }
-
-    self.sample(t).unwrap()
-  }
-}
-
-/// Iterator over spline keys.
-///
-/// This iterator type assures you to iterate over sorted keys.
-pub struct Iter<'a, T> where T: 'a {
-  anim_param: &'a Spline<T>,
-  i: usize
-}
-
-impl<'a, T> Iterator for Iter<'a, T> {
-  type Item = &'a Key<T>;
-
-  fn next(&mut self) -> Option<Self::Item> {
-    let r = self.anim_param.0.get(self.i);
-
-    if let Some(_) = r {
-      self.i += 1;
-    }
-
-    r
-  }
-}
-
-impl<'a, T> IntoIterator for &'a Spline<T> {
-  type Item = &'a Key<T>;
-  type IntoIter = Iter<'a, T>;
-
-  fn into_iter(self) -> Self::IntoIter {
-    Iter {
-      anim_param: self,
-      i: 0
-    }
-  }
-}
-
-/// Keys that can be interpolated in between. Implementing this trait is required to perform
-/// sampling on splines.
-pub trait Interpolate: Copy {
-  /// Linear interpolation.
-  fn lerp(a: Self, b: Self, t: f32) -> Self;
-  /// Cubic hermite interpolation.
-  ///
-  /// Default to `Self::lerp`.
-  fn cubic_hermite(_: (Self, f32), a: (Self, f32), b: (Self, f32), _: (Self, f32), t: f32) -> Self {
-    Self::lerp(a.0, b.0, t)
-  }
-}
-
-impl Interpolate for f32 {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    a * (1. - t) + b * t
-  }
-
-  fn cubic_hermite(x: (Self, f32), a: (Self, f32), b: (Self, f32), y: (Self, f32), t: f32) -> Self {
-    cubic_hermite(x, a, b, y, t)
-  }
-}
+#[cfg(not(feature = "std"))]
+extern crate alloc;
 
 #[cfg(feature = "impl-cgmath")]
-impl Interpolate for Vector2<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    a.lerp(b, t)
-  }
-
-  fn cubic_hermite(x: (Self, f32), a: (Self, f32), b: (Self, f32), y: (Self, f32), t: f32) -> Self {
-    cubic_hermite(x, a, b, y, t)
-  }
-}
-
-#[cfg(feature = "impl-cgmath")]
-impl Interpolate for Vector3<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    a.lerp(b, t)
-  }
-
-  fn cubic_hermite(x: (Self, f32), a: (Self, f32), b: (Self, f32), y: (Self, f32), t: f32) -> Self {
-    cubic_hermite(x, a, b, y, t)
-  }
-}
-
-#[cfg(feature = "impl-cgmath")]
-impl Interpolate for Vector4<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    a.lerp(b, t)
-  }
-
-  fn cubic_hermite(x: (Self, f32), a: (Self, f32), b: (Self, f32), y: (Self, f32), t: f32) -> Self {
-    cubic_hermite(x, a, b, y, t)
-  }
-}
-
-#[cfg(feature = "impl-cgmath")]
-impl Interpolate for Quaternion<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    a.nlerp(b, t)
-  }
-}
-
+mod cgmath;
+pub mod interpolate;
+pub mod interpolation;
+pub mod iter;
+pub mod key;
 #[cfg(feature = "impl-nalgebra")]
-impl<N, D> Interpolate for na::Point<N, D>
-where D: DimName,
-      DefaultAllocator: Allocator<N, D>,
-      <DefaultAllocator as Allocator<N, D>>::Buffer: Copy,
-      N: Scalar + Interpolate {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    // The 'coords' of a point is just a vector, so we can interpolate component-wise
-    // over these vectors.
-    let coords = na::Vector::zip_map(&a.coords, &b.coords, |c1, c2| Interpolate::lerp(c1, c2, t));
-    na::Point::from_coordinates(coords)
-  }
-}
+mod nalgebra;
+pub mod spline;
 
-#[cfg(feature = "impl-nalgebra")]
-impl Interpolate for na::Vector1<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    na::Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
-  }
-}
-
-#[cfg(feature = "impl-nalgebra")]
-impl Interpolate for na::Vector2<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    na::Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
-  }
-}
-
-#[cfg(feature = "impl-nalgebra")]
-impl Interpolate for na::Vector3<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    na::Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
-  }
-}
-
-#[cfg(feature = "impl-nalgebra")]
-impl Interpolate for na::Vector4<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    na::Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
-  }
-}
-
-#[cfg(feature = "impl-nalgebra")]
-impl Interpolate for na::Vector5<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    na::Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
-  }
-}
-
-#[cfg(feature = "impl-nalgebra")]
-impl Interpolate for na::Vector6<f32> {
-  fn lerp(a: Self, b: Self, t: f32) -> Self {
-    na::Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
-  }
-}
-
-// Default implementation of Interpolate::cubic_hermit.
-pub(crate) fn cubic_hermite<T>(x: (T, f32), a: (T, f32), b: (T, f32), y: (T, f32), t: f32) -> T
-    where T: Copy + Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T> + Div<f32, Output = T> {
-  // time stuff
-  let t2 = t * t;
-  let t3 = t2 * t;
-  let two_t3 = 2. * t3;
-  let three_t2 = 3. * t2;
-
-  // tangents
-  let m0 = (b.0 - x.0) / (b.1 - x.1);
-	let m1 = (y.0 - a.0) / (y.1 - a.1);
-
-  a.0 * (two_t3 - three_t2 + 1.) + m0 * (t3 - 2. * t2 + t) + b.0 * (-two_t3 + three_t2) + m1 * (t3 - t2)
-}
-
-// Normalize a time ([0;1]) given two control points.
-#[inline(always)]
-pub(crate) fn normalize_time<T>(t: f32, cp: &Key<T>, cp1: &Key<T>) -> f32 {
-  assert!(cp1.t != cp.t, "overlapping keys");
-
-  (t - cp.t) / (cp1.t - cp.t)
-}
-
-// Find the lower control point corresponding to a given time.
-fn search_lower_cp<T>(cps: &[Key<T>], t: f32) -> Option<usize> {
-  let mut i = 0;
-  let len = cps.len();
-
-  if len < 2 {
-    return None;
-  }
-
-  loop {
-    let cp = &cps[i];
-    let cp1 = &cps[i+1];
-
-    if t >= cp1.t {
-      if i >= len - 2 {
-        return None;
-      }
-
-      i += 1;
-    } else if t < cp.t {
-      if i == 0 {
-        return None;
-      }
-
-      i -= 1;
-    } else {
-      break; // found
-    }
-  }
-
-  Some(i)
-}
+pub use crate::interpolate::Interpolate;
+pub use crate::interpolation::Interpolation;
+pub use crate::key::Key;
+pub use crate::spline::Spline;

src/nalgebra.rs

@@ -0,0 +1,70 @@
+use nalgebra::{Scalar, Vector, Vector1, Vector2, Vector3, Vector4, Vector5, Vector6};
+use num_traits as nt;
+use simba::scalar::{ClosedAdd, ClosedDiv, ClosedMul, ClosedSub};
+use std::ops::Mul;
+
+use crate::interpolate::{
+  cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def, Additive, Interpolate, Linear, One,
+};
+
+macro_rules! impl_interpolate_vector {
+  ($($t:tt)*) => {
+    // implement Linear
+    impl<T> Linear<T> for $($t)*<T>
+    where T: Scalar +
+             Copy +
+             ClosedAdd +
+             ClosedSub +
+             ClosedMul +
+             ClosedDiv {
+      #[inline(always)]
+      fn outer_mul(self, t: T) -> Self {
+        self * t
+      }
+
+      #[inline(always)]
+      fn outer_div(self, t: T) -> Self {
+        self / t
+      }
+    }
+
+    impl<T, V> Interpolate<T> for $($t)*<V>
+    where Self: Linear<T>,
+          T: Additive + One + Mul<T, Output = T>,
+          V: nt::One +
+             nt::Zero +
+             Additive +
+             Scalar +
+             ClosedAdd +
+             ClosedMul +
+             ClosedSub +
+             Interpolate<T> {
+      #[inline(always)]
+      fn lerp(a: Self, b: Self, t: T) -> Self {
+        Vector::zip_map(&a, &b, |c1, c2| Interpolate::lerp(c1, c2, t))
+      }
+
+      #[inline(always)]
+      fn cubic_hermite(x: (Self, T), a: (Self, T), b: (Self, T), y: (Self, T), t: T) -> Self {
+        cubic_hermite_def(x, a, b, y, t)
+      }
+
+      #[inline(always)]
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
+        quadratic_bezier_def(a, u, b, t)
+      }
+
+      #[inline(always)]
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
+        cubic_bezier_def(a, u, v, b, t)
+      }
+    }
+  }
+}
+
+impl_interpolate_vector!(Vector1);
+impl_interpolate_vector!(Vector2);
+impl_interpolate_vector!(Vector3);
+impl_interpolate_vector!(Vector4);
+impl_interpolate_vector!(Vector5);
+impl_interpolate_vector!(Vector6);

src/spline.rs

@@ -0,0 +1,354 @@
+//! Spline curves and operations.
+
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+#[cfg(not(feature = "std"))]
+use core::cmp::Ordering;
+#[cfg(not(feature = "std"))]
+use core::ops::{Div, Mul};
+#[cfg(feature = "serialization")]
+use serde_derive::{Deserialize, Serialize};
+#[cfg(feature = "std")]
+use std::cmp::Ordering;
+#[cfg(feature = "std")]
+use std::ops::{Div, Mul};
+
+use crate::interpolate::{Additive, Interpolate, One, Trigo};
+use crate::interpolation::Interpolation;
+use crate::key::Key;
+
+/// Spline curve used to provide interpolation between control points (keys).
+///
+/// Splines are made out of control points ([`Key`]). When creating a [`Spline`] with
+/// [`Spline::from_vec`] or [`Spline::from_iter`], the keys don’t have to be sorted (they are sorted
+/// automatically by the sampling value).
+///
+/// You can sample from a spline with several functions:
+///
+///   - [`Spline::sample`]: allows you to sample from a spline. If not enough keys are available
+///     for the required interpolation mode, you get `None`.
+///   - [`Spline::clamped_sample`]: behaves like [`Spline::sample`] but will return either the first
+///     or last key if out of bound; it will return `None` if not enough key.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
+pub struct Spline<T, V>(pub(crate) Vec<Key<T, V>>);
+
+impl<T, V> Spline<T, V> {
+  /// Internal sort to ensure invariant of sorting keys is valid.
+  fn internal_sort(&mut self)
+  where
+    T: PartialOrd,
+  {
+    self
+      .0
+      .sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less));
+  }
+
+  /// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended
+  /// to provide ascending sorted ones (for performance purposes).
+  pub fn from_vec(keys: Vec<Key<T, V>>) -> Self
+  where
+    T: PartialOrd,
+  {
+    let mut spline = Spline(keys);
+    spline.internal_sort();
+    spline
+  }
+
+  /// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
+  /// sorted.
+  ///
+  /// # Note on iterators
+  ///
+  /// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should
+  /// use [`Spline::from_vec`] if you are passing a [`Vec`].
+  pub fn from_iter<I>(iter: I) -> Self
+  where
+    I: Iterator<Item = Key<T, V>>,
+    T: PartialOrd,
+  {
+    Self::from_vec(iter.collect())
+  }
+
+  /// Retrieve the keys of a spline.
+  pub fn keys(&self) -> &[Key<T, V>] {
+    &self.0
+  }
+
+  /// Number of keys.
+  #[inline(always)]
+  pub fn len(&self) -> usize {
+    self.0.len()
+  }
+
+  /// Check whether the spline has no key.
+  #[inline(always)]
+  pub fn is_empty(&self) -> bool {
+    self.0.is_empty()
+  }
+
+  /// Sample a spline at a given time, returning the interpolated value along with its associated
+  /// key.
+  ///
+  /// The current implementation, based on immutability, cannot perform in constant time. This means
+  /// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
+  /// performance by using a slightly different spline type. If you are interested by this feature,
+  /// an implementation for a dedicated type is foreseen yet not started yet.
+  ///
+  /// # Return
+  ///
+  /// `None` if you try to sample a value at a time that has no key associated with. That can also
+  /// happen if you try to sample between two keys with a specific interpolation mode that makes the
+  /// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
+  /// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
+  /// the sampling.
+  pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
+  where
+    T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+    V: Additive + Interpolate<T>,
+  {
+    let keys = &self.0;
+    let i = search_lower_cp(keys, t)?;
+    let cp0 = &keys[i];
+
+    match cp0.interpolation {
+      Interpolation::Step(threshold) => {
+        let cp1 = &keys[i + 1];
+        let nt = normalize_time(t, cp0, cp1);
+        let value = if nt < threshold { cp0.value } else { cp1.value };
+
+        Some((value, cp0, Some(cp1)))
+      }
+
+      Interpolation::Linear => {
+        let cp1 = &keys[i + 1];
+        let nt = normalize_time(t, cp0, cp1);
+        let value = Interpolate::lerp(cp0.value, cp1.value, nt);
+
+        Some((value, cp0, Some(cp1)))
+      }
+
+      Interpolation::Cosine => {
+        let two_t = T::one() + T::one();
+        let cp1 = &keys[i + 1];
+        let nt = normalize_time(t, cp0, cp1);
+        let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
+        let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
+
+        Some((value, cp0, Some(cp1)))
+      }
+
+      Interpolation::CatmullRom => {
+        // We need at least four points for Catmull Rom; ensure we have them, otherwise, return
+        // None.
+        if i == 0 || i >= keys.len() - 2 {
+          None
+        } else {
+          let cp1 = &keys[i + 1];
+          let cpm0 = &keys[i - 1];
+          let cpm1 = &keys[i + 2];
+          let nt = normalize_time(t, cp0, cp1);
+          let value = Interpolate::cubic_hermite(
+            (cpm0.value, cpm0.t),
+            (cp0.value, cp0.t),
+            (cp1.value, cp1.t),
+            (cpm1.value, cpm1.t),
+            nt,
+          );
+
+          Some((value, cp0, Some(cp1)))
+        }
+      }
+
+      Interpolation::Bezier(u) | Interpolation::StrokeBezier(_, u) => {
+        // We need to check the next control point to see whether we want quadratic or cubic Bezier.
+        let cp1 = &keys[i + 1];
+        let nt = normalize_time(t, cp0, cp1);
+
+        let value = match cp1.interpolation {
+          Interpolation::Bezier(v) => {
+            Interpolate::cubic_bezier(cp0.value, u, cp1.value + cp1.value - v, cp1.value, nt)
+          }
+
+          Interpolation::StrokeBezier(v, _) => {
+            Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
+          }
+
+          _ => Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt),
+        };
+
+        Some((value, cp0, Some(cp1)))
+      }
+
+      Interpolation::__NonExhaustive => unreachable!(),
+    }
+  }
+
+  /// Sample a spline at a given time.
+  ///
+  pub fn sample(&self, t: T) -> Option<V>
+  where
+    T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+    V: Additive + Interpolate<T>,
+  {
+    self.sample_with_key(t).map(|(v, _, _)| v)
+  }
+
+  /// Sample a spline at a given time with clamping, returning the interpolated value along with its
+  /// associated key.
+  ///
+  /// # Return
+  ///
+  /// If you sample before the first key or after the last one, return the first key or the last
+  /// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
+  ///
+  /// # Error
+  ///
+  /// This function returns [`None`] if you have no key.
+  pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
+  where
+    T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+    V: Additive + Interpolate<T>,
+  {
+    if self.0.is_empty() {
+      return None;
+    }
+
+    self.sample_with_key(t).or_else(move || {
+      let first = self.0.first().unwrap();
+      if t <= first.t {
+        let second = if self.0.len() >= 2 {
+          Some(&self.0[1])
+        } else {
+          None
+        };
+        Some((first.value, &first, second))
+      } else {
+        let last = self.0.last().unwrap();
+
+        if t >= last.t {
+          Some((last.value, &last, None))
+        } else {
+          None
+        }
+      }
+    })
+  }
+
+  /// Sample a spline at a given time with clamping.
+  pub fn clamped_sample(&self, t: T) -> Option<V>
+  where
+    T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+    V: Additive + Interpolate<T>,
+  {
+    self.clamped_sample_with_key(t).map(|(v, _, _)| v)
+  }
+
+  /// Add a key into the spline.
+  pub fn add(&mut self, key: Key<T, V>)
+  where
+    T: PartialOrd,
+  {
+    self.0.push(key);
+    self.internal_sort();
+  }
+
+  /// Remove a key from the spline.
+  pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
+    if index >= self.0.len() {
+      None
+    } else {
+      Some(self.0.remove(index))
+    }
+  }
+
+  /// Update a key and return the key already present.
+  ///
+  /// The key is updated — if present — with the provided function.
+  ///
+  /// # Notes
+  ///
+  /// That function makes sense only if you want to change the interpolator (i.e. [`Key::t`]) of
+  /// your key. If you just want to change the interpolation mode or the carried value, consider
+  /// using the [`Spline::get_mut`] method instead as it will be way faster.
+  pub fn replace<F>(&mut self, index: usize, f: F) -> Option<Key<T, V>>
+  where
+    F: FnOnce(&Key<T, V>) -> Key<T, V>,
+    T: PartialOrd,
+  {
+    let key = self.remove(index)?;
+    self.add(f(&key));
+    Some(key)
+  }
+
+  /// Get a key at a given index.
+  pub fn get(&self, index: usize) -> Option<&Key<T, V>> {
+    self.0.get(index)
+  }
+
+  /// Mutably get a key at a given index.
+  pub fn get_mut(&mut self, index: usize) -> Option<KeyMut<T, V>> {
+    self.0.get_mut(index).map(|key| KeyMut {
+      value: &mut key.value,
+      interpolation: &mut key.interpolation,
+    })
+  }
+}
+
+/// A mutable [`Key`].
+///
+/// Mutable keys allow to edit the carried values and the interpolation mode but not the actual
+/// interpolator value as it would invalidate the internal structure of the [`Spline`]. If you
+/// want to achieve this, you’re advised to use [`Spline::replace`].
+pub struct KeyMut<'a, T, V> {
+  /// Carried value.
+  pub value: &'a mut V,
+  /// Interpolation mode to use for that key.
+  pub interpolation: &'a mut Interpolation<T, V>,
+}
+
+// Normalize a time ([0;1]) given two control points.
+#[inline(always)]
+pub(crate) fn normalize_time<T, V>(t: T, cp: &Key<T, V>, cp1: &Key<T, V>) -> T
+where
+  T: Additive + Div<T, Output = T> + PartialEq,
+{
+  assert!(cp1.t != cp.t, "overlapping keys");
+  (t - cp.t) / (cp1.t - cp.t)
+}
+
+// Find the lower control point corresponding to a given time.
+fn search_lower_cp<T, V>(cps: &[Key<T, V>], t: T) -> Option<usize>
+where
+  T: PartialOrd,
+{
+  let mut i = 0;
+  let len = cps.len();
+
+  if len < 2 {
+    return None;
+  }
+
+  loop {
+    let cp = &cps[i];
+    let cp1 = &cps[i + 1];
+
+    if t >= cp1.t {
+      if i >= len - 2 {
+        return None;
+      }
+
+      i += 1;
+    } else if t < cp.t {
+      if i == 0 {
+        return None;
+      }
+
+      i -= 1;
+    } else {
+      break; // found
+    }
+  }
+
+  Some(i)
+}

tests/mod.rs

@@ -1,16 +1,15 @@
-extern crate splines;
-#[cfg(feature = "impl-nalgebra")] extern crate nalgebra;
-
-#[cfg(feature = "impl-nalgebra")] use nalgebra as na;
-#[cfg(feature = "impl-nalgebra")] use splines::Interpolate;
-
 use splines::{Interpolation, Key, Spline};
 
+#[cfg(feature = "cgmath")]
+use cgmath as cg;
+#[cfg(feature = "nalgebra")]
+use nalgebra as na;
+
 #[test]
-fn step_interpolation_0() {
+fn step_interpolation_f32() {
   let start = Key::new(0., 0., Interpolation::Step(0.));
   let end = Key::new(1., 10., Interpolation::default());
-  let spline = Spline::from_vec(vec![start, end]);
+  let spline = Spline::<f32, _>::from_vec(vec![start, end]);
 
   assert_eq!(spline.sample(0.), Some(10.));
   assert_eq!(spline.sample(0.1), Some(10.));
@@ -18,7 +17,26 @@ fn step_interpolation_0() {
   assert_eq!(spline.sample(0.5), Some(10.));
   assert_eq!(spline.sample(0.9), Some(10.));
   assert_eq!(spline.sample(1.), None);
-  assert_eq!(spline.clamped_sample(1.), 10.);
+  assert_eq!(spline.clamped_sample(1.), Some(10.));
+  assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end))));
+  assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None)));
+}
+
+#[test]
+fn step_interpolation_f64() {
+  let start = Key::new(0., 0., Interpolation::Step(0.));
+  let end = Key::new(1., 10., Interpolation::default());
+  let spline = Spline::<f64, _>::from_vec(vec![start, end]);
+
+  assert_eq!(spline.sample(0.), Some(10.));
+  assert_eq!(spline.sample(0.1), Some(10.));
+  assert_eq!(spline.sample(0.2), Some(10.));
+  assert_eq!(spline.sample(0.5), Some(10.));
+  assert_eq!(spline.sample(0.9), Some(10.));
+  assert_eq!(spline.sample(1.), None);
+  assert_eq!(spline.clamped_sample(1.), Some(10.));
+  assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end))));
+  assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None)));
 }
 
 #[test]
@@ -33,7 +51,7 @@ fn step_interpolation_0_5() {
   assert_eq!(spline.sample(0.5), Some(10.));
   assert_eq!(spline.sample(0.9), Some(10.));
   assert_eq!(spline.sample(1.), None);
-  assert_eq!(spline.clamped_sample(1.), 10.);
+  assert_eq!(spline.clamped_sample(1.), Some(10.));
 }
 
 #[test]
@@ -48,7 +66,7 @@ fn step_interpolation_0_75() {
   assert_eq!(spline.sample(0.5), Some(0.));
   assert_eq!(spline.sample(0.9), Some(10.));
   assert_eq!(spline.sample(1.), None);
-  assert_eq!(spline.clamped_sample(1.), 10.);
+  assert_eq!(spline.clamped_sample(1.), Some(10.));
 }
 
 #[test]
@@ -63,7 +81,7 @@ fn step_interpolation_1() {
   assert_eq!(spline.sample(0.5), Some(0.));
   assert_eq!(spline.sample(0.9), Some(0.));
   assert_eq!(spline.sample(1.), None);
-  assert_eq!(spline.clamped_sample(1.), 10.);
+  assert_eq!(spline.clamped_sample(1.), Some(10.));
 }
 
 #[test]
@@ -78,7 +96,7 @@ fn linear_interpolation() {
   assert_eq!(spline.sample(0.5), Some(5.));
   assert_eq!(spline.sample(0.9), Some(9.));
   assert_eq!(spline.sample(1.), None);
-  assert_eq!(spline.clamped_sample(1.), 10.);
+  assert_eq!(spline.clamped_sample(1.), Some(10.));
 }
 
 #[test]
@@ -103,7 +121,7 @@ fn linear_interpolation_several_keys() {
   assert_eq!(spline.sample(3.), Some(1.));
   assert_eq!(spline.sample(6.5), Some(1.5));
   assert_eq!(spline.sample(10.), Some(2.));
-  assert_eq!(spline.clamped_sample(11.), 4.);
+  assert_eq!(spline.clamped_sample(11.), Some(4.));
 }
 
 #[test]
@@ -125,29 +143,60 @@ fn several_interpolations_several_keys() {
   assert_eq!(spline.sample(1.5), Some(2.5));
   assert_eq!(spline.sample(2.), Some(0.));
   assert_eq!(spline.sample(2.05), Some(0.));
-  assert_eq!(spline.sample(2.1), Some(0.));
+  assert_eq!(spline.sample(2.099), Some(0.));
   assert_eq!(spline.sample(2.75), Some(1.));
   assert_eq!(spline.sample(3.), Some(1.));
   assert_eq!(spline.sample(6.5), Some(1.5));
   assert_eq!(spline.sample(10.), Some(2.));
-  assert_eq!(spline.clamped_sample(11.), 4.);
+  assert_eq!(spline.clamped_sample(11.), Some(4.));
 }
 
-#[cfg(feature = "impl-nalgebra")]
+#[cfg(feature = "cgmath")]
 #[test]
-fn nalgebra_point_interpolation() {
-  let start = na::Point2::new(0.0, 0.0);
-  let mid = na::Point2::new(0.5, 0.5);
-  let end = na::Point2::new(1.0, 1.0);
+fn stroke_bezier_straight() {
+  use float_cmp::approx_eq;
+
+  let keys = vec![
+    Key::new(
+      0.0,
+      cg::Vector2::new(0., 1.),
+      Interpolation::StrokeBezier(cg::Vector2::new(0., 1.), cg::Vector2::new(0., 1.)),
+    ),
+    Key::new(
+      5.0,
+      cg::Vector2::new(5., 1.),
+      Interpolation::StrokeBezier(cg::Vector2::new(5., 1.), cg::Vector2::new(5., 1.)),
+    ),
+  ];
+  let spline = Spline::from_vec(keys);
+
+  assert!(approx_eq!(f32, spline.clamped_sample(0.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(1.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(2.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(3.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(4.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(5.0).unwrap().y, 1.));
+}
+
+#[cfg(feature = "cgmath")]
+#[test]
+fn cgmath_vector_interpolation() {
+  use splines::Interpolate;
+
+  let start = cg::Vector2::new(0.0, 0.0);
+  let mid = cg::Vector2::new(0.5, 0.5);
+  let end = cg::Vector2::new(1.0, 1.0);
 
   assert_eq!(Interpolate::lerp(start, end, 0.0), start);
   assert_eq!(Interpolate::lerp(start, end, 1.0), end);
   assert_eq!(Interpolate::lerp(start, end, 0.5), mid);
 }
 
-#[cfg(feature = "impl-nalgebra")]
+#[cfg(feature = "nalgebra")]
 #[test]
 fn nalgebra_vector_interpolation() {
+  use splines::Interpolate;
+
   let start = na::Vector2::new(0.0, 0.0);
   let mid = na::Vector2::new(0.5, 0.5);
   let end = na::Vector2::new(1.0, 1.0);
@@ -157,3 +206,50 @@ fn nalgebra_vector_interpolation() {
   assert_eq!(Interpolate::lerp(start, end, 0.5), mid);
 }
 
+#[test]
+fn add_key_empty() {
+  let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]);
+  spline.add(Key::new(0., 0., Interpolation::Linear));
+
+  assert_eq!(spline.keys(), &[Key::new(0., 0., Interpolation::Linear)]);
+}
+
+#[test]
+fn add_key() {
+  let start = Key::new(0., 0., Interpolation::Step(0.5));
+  let k1 = Key::new(1., 5., Interpolation::Linear);
+  let k2 = Key::new(2., 0., Interpolation::Step(0.1));
+  let k3 = Key::new(3., 1., Interpolation::Linear);
+  let k4 = Key::new(10., 2., Interpolation::Linear);
+  let end = Key::new(11., 4., Interpolation::default());
+  let new = Key::new(2.4, 40., Interpolation::Linear);
+  let mut spline = Spline::from_vec(vec![start, k1, k2.clone(), k3, k4, end]);
+
+  assert_eq!(spline.keys(), &[start, k1, k2, k3, k4, end]);
+  spline.add(new);
+  assert_eq!(spline.keys(), &[start, k1, k2, new, k3, k4, end]);
+}
+
+#[test]
+fn remove_element_empty() {
+  let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]);
+  let removed = spline.remove(0);
+
+  assert_eq!(removed, None);
+  assert!(spline.is_empty());
+}
+
+#[test]
+fn remove_element() {
+  let start = Key::new(0., 0., Interpolation::Step(0.5));
+  let k1 = Key::new(1., 5., Interpolation::Linear);
+  let k2 = Key::new(2., 0., Interpolation::Step(0.1));
+  let k3 = Key::new(3., 1., Interpolation::Linear);
+  let k4 = Key::new(10., 2., Interpolation::Linear);
+  let end = Key::new(11., 4., Interpolation::default());
+  let mut spline = Spline::from_vec(vec![start, k1, k2.clone(), k3, k4, end]);
+  let removed = spline.remove(2);
+
+  assert_eq!(removed, Some(k2));
+  assert_eq!(spline.len(), 5);
+}