24 changed files with 524 additions and 1000 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@ -1,25 +0,0 @@
-version: 2
-updates:
- package-ecosystem: cargo
-  directory: "/."
-  schedule:
-    interval: daily
-    time: "04:00"
-  open-pull-requests-limit: 10
-  target-branch: master
-  reviewers:
-  - phaazon
-  assignees:
-  - phaazon
-  labels:
-  - dependency-update
-  ignore:
-  - dependency-name: glam
-    versions:
-    - 0.13.0
-  - dependency-name: nalgebra
-    versions:
-    - 0.25.0
-  - dependency-name: cgmath
-    versions:
-    - 0.18.0
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@ -1,38 +1,39 @@
 name: CI
-on: [push, pull_request]
+on: [push]

 jobs:
  build-linux:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v1
+      - name: Build
+        run: cargo build --verbose
      - name: Test
-        run: cargo test --verbose --all-features
+        run: cargo test --verbose

  build-windows:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v1
+      - name: Build
+        run: cargo build --verbose
      - name: Test
-        run: cargo test --verbose --all-features
+        run: cargo test --verbose

  build-macosx:
-    runs-on: macOS-latest
+    runs-on: macosx-latest
    steps:
      - uses: actions/checkout@v1
+      - name: Build
+        run: cargo build --verbose
      - name: Test
-        run: cargo test --verbose --all-features
+        run: cargo test --verbose

-  quality:
+  check-readme:
    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
+      - name: Install cargo-sync-readme
+        run: cargo install --force cargo-sync-readme
+      - name: Check
+        run: cargo sync-readme -c
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,263 +1,6 @@
-# Changelog
-
-* [4.3.1](#431)
-* [4.3](#43)
-* [4.2](#42)
-* [4.1.1](#411)
-* [4.1](#41)
-* [4.0.3](#403)
-* [4.0.2](#402)
-* [4.0.1](#401)
-* [4.0](#40)
-  * [Major changes](#major-changes)
-  * [Patch changes](#patch-changes)
-* [3.5.4](#354)
-* [3.5.3](#353)
-* [3.5.2](#352)
-* [3.5.1](#351)
-* [3.5](#35)
-* [3.4.2](#342)
-* [3.4.1](#341)
-* [3.4](#34)
-* [3.3](#33)
-* [3.2](#32)
-* [3.1](#31)
-* [3.0](#30)
-  * [Major changes](#major-changes-1)
-  * [Patch changes](#patch-changes-1)
-* [2.2](#22)
-* [2.1.1](#211)
-* [2.1](#21)
-* [2.0.1](#201)
-* [2.0](#20)
-  * [Major changes](#major-changes-2)
-  * [Minor changes](#minor-changes)
-* [1.0](#10)
-  * [Major changes](#major-changes-3)
-  * [Minor changes](#minor-changes-1)
-  * [Patch changes](#patch-changes-2)
-* [0.2.3](#023)
-* [0.2.2](#022)
-* [0.2.1](#021)
-* [0.2](#02)
-* [0.1.1](#011)
-* [0.1](#01)
-
-# 4.3.1
-
-> Nov 22, 2023
-
- Add `Default` implementation for `Spline`. [c6ba847](https://github.com/phaazon/splines/commit/c6ba847)
-
-# 4.3
-
-> Sep 23, 2023
-
- Add support for `glam-0.23` and `glam-0.24`. [cdc48a4](https://github.com/phaazon/splines/commit/cdc48a4)
- Add `Spline::clear` to clear a spline keys without deallocating its internal storage. [eca09f1](https://github.com/phaazon/splines/commit/eca09f1)
-
-# 4.2
-
-> Feb 1, 2023
-
- Add support for `glam-0.22`.
- Add support for `nalgebra-0.32`.
- Add deprecation lints for `impl-*` feature gates. Those shouldn’t be used anymore and the `*` variant should be 
-  preferred. For instance, if you used `impl-cgmath`, you should just use the `cgmath` feature gate now.
-
-# 4.1.1
-
-> Jul 27, 2022
-
- Internal enhancement of sampling splines by looking for control points. That brings the lookup from _O(N)_ to
-  _O(log(N))_. That is super embarassing because it should have been the default from the very first commit. Sorry
-  about that.
- Fix hermite cubic interpolation.
- Add support for `glam-0.21`.
- Add support for `nalgebra-0.31`.
-
-# 4.1
-
-> Mar 28, 2022
-
- Support for edition 2021.
- Bump `float-cmp` dependency.
- Bump `glam` dependency.
- Bump `nalgebra` dependency.
- Simplify the CI.
-
-# 4.0.3
-
-> Jul 11, 2021
-
- Add more implementors for `Interpolate`.
-
-# 4.0.2
-
-> Jul 11, 2021
-
- **Yanked.**
-
-# 4.0.1
-
-> Jul 11, 2021
-
- Add support up to `glam-0.17`.
- Add support up to `nalgebra-0.27`.
- Replace the name of some feature gates:
-  - `serialization` becomes `serde`.
-  - `impl-*` becomes `*`.
-  - The previous feature gates are kept around to prevent a breaking change but will eventually be removed in the next
-    major update.
-
-# 4.0
-
-> Mar 05, 2021
-
-## Major changes
-
- Switch the `Interpolation` enum to `#[non_exhaustive]` to allow adding more interpolation modes (if any) in the
-  future.
- Introduce `SampledWithKey`, which is a more elegant / typed way to access a sample along with its associated key
-  index.
- Refactor the `Interpolate` trait and add the `Interpolator` trait.
-
-## Patch changes
-
- Highly simplify the various implementors (`cgmath`, `nalgebra` and `glam`) so that maintenance is easy.
- Expose the `impl_Interpolate` macro, allowing to implement the API all at once if a type implements the various
-  `std::ops:*` traits. Since most of the crates do, this macro makes it really easy to add support for a crate.
- Drop `simba` as a direct dependency.
- Drop `num-traits` as a direct dependency.
-
-# 3.5.4
-
-> Feb 27, 2021
-
- Support of `cgmath-0.18`.
-
-# 3.5.3
-
-> Jan 16, 2021
-
- Resynchronize and fix links in the README (fix in `cargo sync-readme`).
-
-# 3.5.2
-
-> Fri Jan 01, 2021
-
- Support of `nalgebra-0.24`.
-
-# 3.5.1
-
-> Dec 5th, 2020
-
- Support of `glam-0.11`.
-
-# 3.5
-
-> Nov 23rd, 2020
-
- Add support for [glam](https://crates.io/crates/glam) via the `"impl-glam"` feature gate.
- Support of `nalgebra-0.23`.
-
-# 3.4.2
-
-> Oct 24th, 2020
-
- Support of `simba-0.3`.
-
-# 3.4.1
-
-> Sep 5th, 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
+> Sun Sep 22th 2019

 ## Major changes

--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "splines"
-version = "4.3.1"
+version = "1.0.0"
 license = "BSD-3-Clause"
 authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
 description = "Spline interpolation made easy"
@ -11,32 +11,28 @@ repository = "https://github.com/phaazon/splines"
 documentation = "https://docs.rs/splines"
 readme = "README.md"

-edition = "2021"
+edition = "2018"
+
+[badges]
+travis-ci = { repository = "phaazon/splines", branch = "master" }
+is-it-maintained-issue-resolution = { repository = "phaazon/splines" }
+is-it-maintained-open-issues = { repository = "phaazon/splines" }
+maintenance = { status = "actively-developed" }

 [features]
 default = ["std"]
 impl-cgmath = ["cgmath"]
-impl-glam = ["glam"]
-impl-nalgebra = ["nalgebra"]
-serialization = ["serde"]
-std = ["nalgebra/std"]
+impl-nalgebra = ["alga", "nalgebra", "num-traits"]
+serialization = ["serde", "serde_derive"]
+std = []

 [dependencies]
-cgmath = { version = ">=0.17, <0.19", optional = true }
-glam = { version = ">=0.10, <0.25", optional = true }
-nalgebra = { version = ">=0.21, <0.33", default-features = false, optional = true }
-serde = { version = "1", features = ["derive"], optional = true }
-
-[dev-dependencies]
-float-cmp = ">=0.6, < 0.10"
-serde_json = "1"
+alga = { version = "0.9", optional = true }
+cgmath = { version = "0.17", optional = true }
+nalgebra = { version = ">=0.14, <0.19", optional = true }
+num-traits = { version = "0.2", optional = true }
+serde =  { version = "1", optional = true }
+serde_derive = { version = "1", optional = true }

 [package.metadata.docs.rs]
-features = ["std", "cgmath", "glam", "nalgebra", "serde"]
-
-[[example]]
-name = "hello-world"
-
-[[example]]
-name = "serialization"
-required-features = ["serde"]
+all-features = true
--- a/30
+++ b/30
@ -1,30 +0,0 @@
-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.
--- a/README.md
+++ b/README.md
@ -24,7 +24,7 @@ is picked from its lower control point.

 # Quickly create splines

-```rust
+```
 use splines::{Interpolation, Key, Spline};

 let start = Key::new(0., 0., Interpolation::Linear);
@ -46,7 +46,7 @@ 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);
@ -56,7 +56,7 @@ It’s possible that you want to get a value even if you’re out-of-bounds. Thi
 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
 ```
@ -66,7 +66,7 @@ assert_eq!(spline.clamped_sample(1.1), Some(10.)); // clamped to the last key
 [`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](https://docs.rs/splines/latest/splines/interpolate/) for further details.
+implement. See [the documentation of this module](crate::interpolate) for further details.

 # Features and customization

@ -83,25 +83,20 @@ 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:

-  - **Serde.**
-    - This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
+  - **Serialization / deserialization.**
+    + This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
      types exported by this crate.
-    - Enable with the `"serde"` 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 `"cgmath"` feature.
-  - **[glam](https://crates.io/crates/glam) implementors.**
-    - Adds some useful implementations of `Interpolate` for some glam types.
-    - Enable with the `"glam"` 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 `"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.
-
-[`Interpolation`]: crate::interpolation::Interpolation
+    + 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.

 <!-- cargo-sync-readme end -->
--- a/examples/01-hello-world/Cargo.toml
+++ b/examples/01-hello-world/Cargo.toml
@ -0,0 +1,7 @@
+[package]
+name = "hello-world"
+version = "0.2.0"
+authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
+
+[dependencies]
+splines = "1.0.0-rc.2"
--- a/examples/01-hello-world/src/main.rs
+++ b/examples/01-hello-world/src/main.rs
@ -3,10 +3,7 @@ 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 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.));
--- a/examples/02-serialization/Cargo.toml
+++ b/examples/02-serialization/Cargo.toml
@ -0,0 +1,8 @@
+[package]
+name = "serialization"
+version = "0.2.0"
+authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
+
+[dependencies]
+serde_json = "1"
+splines =  { version = "1.0.0-rc.2", features = ["serialization"] }
--- a/examples/02-serialization/src/main.rs
+++ b/examples/02-serialization/src/main.rs
@ -1,12 +1,11 @@
-#[macro_use]
-extern crate serde_json;
+#[macro_use] extern crate serde_json;
 extern crate splines;

 use serde_json::from_value;
 use splines::Spline;

 fn main() {
-  let value = json! {
+  let value = json!{
    [
      {
        "t": 0,
--- a/examples/Cargo.toml
+++ b/examples/Cargo.toml
@ -0,0 +1,9 @@
+[workspace]
+
+members = [
+  "01-hello-world",
+  "02-serialization"
+]
+
+[patch.crates-io]
+splines = { path = ".." }
--- a/rustfmt.toml
+++ b/rustfmt.toml
@ -1,15 +0,0 @@
-edition = "2018"
-
-fn_params_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
--- a/src/cgmath.rs
+++ b/src/cgmath.rs
@ -1,15 +1,64 @@
-use crate::impl_Interpolate;
+use cgmath::{
+  BaseFloat, BaseNum, InnerSpace, Quaternion, Vector1, Vector2, Vector3, Vector4, VectorSpace
+};

-use cgmath::{Quaternion, Vector1, Vector2, Vector3, Vector4};
+use crate::interpolate::{Additive, Interpolate, Linear, One, cubic_hermite_def};

-impl_Interpolate!(f32, Vector1<f32>, std::f32::consts::PI);
-impl_Interpolate!(f32, Vector2<f32>, std::f32::consts::PI);
-impl_Interpolate!(f32, Vector3<f32>, std::f32::consts::PI);
-impl_Interpolate!(f32, Vector4<f32>, std::f32::consts::PI);
-impl_Interpolate!(f32, Quaternion<f32>, std::f32::consts::PI);
+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
+      }

-impl_Interpolate!(f64, Vector1<f64>, std::f64::consts::PI);
-impl_Interpolate!(f64, Vector2<f64>, std::f64::consts::PI);
-impl_Interpolate!(f64, Vector3<f64>, std::f64::consts::PI);
-impl_Interpolate!(f64, Vector4<f64>, std::f64::consts::PI);
-impl_Interpolate!(f64, Quaternion<f64>, std::f64::consts::PI);
+      #[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)
+      }
+    }
+  }
+}
+
+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)
+  }
+}
--- a/src/glam.rs
+++ b/src/glam.rs
@ -1,8 +0,0 @@
-use crate::impl_Interpolate;
-use glam::{Quat, Vec2, Vec3, Vec3A, Vec4};
-
-impl_Interpolate!(f32, Vec2, std::f32::consts::PI);
-impl_Interpolate!(f32, Vec3, std::f32::consts::PI);
-impl_Interpolate!(f32, Vec3A, std::f32::consts::PI);
-impl_Interpolate!(f32, Vec4, std::f32::consts::PI);
-impl_Interpolate!(f32, Quat, std::f32::consts::PI);
--- a/src/interpolate.rs
+++ b/src/interpolate.rs
@ -28,220 +28,220 @@
 //! [`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::f32;
+#[cfg(not(feature = "std"))] use core::f32;
+#[cfg(not(feature = "std"))] use core::intrinsics::cosf32;
+#[cfg(feature = "std")] use std::f64;
+#[cfg(not(feature = "std"))] use core::f64;
+#[cfg(not(feature = "std"))] use core::intrinsics::cosf64;
+#[cfg(feature = "std")] use std::ops::{Add, Mul, Sub};
+#[cfg(not(feature = "std"))] use core::ops::{Add, Mul, Sub};

-/// Types that can be used as interpolator in splines.
+/// Keys that can be interpolated in between. Implementing this trait is required to perform
+/// sampling on splines.
 ///
-/// An interpolator value is like the fabric on which control keys (and sampled values) live on.
-pub trait Interpolator: Sized + Copy + PartialOrd {
-  /// Normalize the interpolator.
-  fn normalize(self, start: Self, end: Self) -> Self;
-}
-
-macro_rules! impl_Interpolator {
-  ($t:ty) => {
-    impl Interpolator for $t {
-      fn normalize(self, start: Self, end: Self) -> Self {
-        (self - start) / (end - start)
-      }
-    }
-  };
-}
-
-impl_Interpolator!(f32);
-impl_Interpolator!(f64);
-
-/// Values that can be interpolated. 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.
 ///
-/// `T` is the interpolator used to sample with. Typical implementations use [`f32`] or [`f64`], but
-/// you’re free to use the ones you like.
+/// [`Spline::sample`]: crate::spline::Spline::sample
 pub trait Interpolate<T>: Sized + Copy {
-  /// Step interpolation.
-  fn step(t: T, threshold: T, a: Self, b: Self) -> Self;
-
  /// Linear interpolation.
-  fn lerp(t: T, a: Self, b: Self) -> Self;
-
-  /// Cosine interpolation.
-  fn cosine(t: T, a: Self, b: Self) -> Self;
+  fn lerp(a: Self, b: Self, t: T) -> Self;

  /// Cubic hermite interpolation.
-  fn cubic_hermite(t: T, x: (T, Self), a: (T, Self), b: (T, Self), y: (T, Self)) -> Self;
-
-  /// Quadratic Bézier interpolation.
  ///
-  /// `a` is the first point; `b` is the second point and `u` is the tangent of `a` to the curve.
-  fn quadratic_bezier(t: T, a: Self, u: Self, b: Self) -> Self;
-
-  /// Cubic Bézier interpolation.
+  /// Default to [`lerp`].
  ///
-  /// `a` is the first point; `b` is the second point; `u` is the output tangent of `a` to the curve and `v` is the
-  /// input tangent of `b` to the curve.
-  fn cubic_bezier(t: T, a: Self, u: Self, v: Self, b: Self) -> Self;
-
-  /// Cubic Bézier interpolation – special case for non-explicit second tangent.
-  ///
-  /// This version does the same computation as [`Interpolate::cubic_bezier`] but computes the second tangent by
-  /// inversing it (typical when the next point uses a Bézier interpolation, where input and output tangents are
-  /// mirrored for the same key).
-  fn cubic_bezier_mirrored(t: T, a: Self, u: Self, v: Self, b: Self) -> Self;
+  /// [`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)
+  }
 }

-#[macro_export]
-macro_rules! impl_Interpolate {
-  ($t:ty, $v:ty, $pi:expr) => {
-    impl $crate::interpolate::Interpolate<$t> for $v {
-      fn step(t: $t, threshold: $t, a: Self, b: Self) -> Self {
-        if t < threshold {
-          a
-        } else {
-          b
-        }
+/// 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
      }

-      #[cfg(feature = "std")]
-      fn cosine(t: $t, a: Self, b: Self) -> Self {
-        let cos_nt = (1. - (t * $pi).cos()) * 0.5;
-        <Self as $crate::interpolate::Interpolate<$t>>::lerp(cos_nt, a, b)
+      /// Apply an outer division law.
+      fn outer_div(self, t: $t) -> Self {
+        self / t
      }
-      #[cfg(not(feature = "std"))]
-      fn cosine(t: $t, a: Self, b: Self) -> Self {
-        unimplemented!();
+    }
+  }
+}
+
+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
      }

-      fn lerp(t: $t, a: Self, b: Self) -> Self {
+      /// 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)
+}
+
+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(t: $t, x: ($t, Self), a: ($t, Self), b: ($t, Self), y: ($t, Self)) -> Self {
-        // sampler stuff
-        let two_t = t * 2.;
-        let three_t = t * 3.;
-        let t2 = t * t;
-        let t3 = t2 * t;
-        let two_t3 = t2 * two_t;
-        let two_t2 = t * two_t;
-        let three_t2 = t * three_t;
-
-        // tangents
-        let m0 = (b.1 - x.1) / (b.0 - x.0) * (b.0 - a.0);
-        let m1 = (y.1 - a.1) / (y.0 - a.0) * (b.0 - a.0);
-
-        a.1 * (two_t3 - three_t2 + 1.)
-          + m0 * (t3 - two_t2 + t)
-          + b.1 * (three_t2 - two_t3)
-          + m1 * (t3 - t2)
-      }
-
-      fn quadratic_bezier(t: $t, a: Self, u: Self, b: Self) -> Self {
-        let one_t = 1. - t;
-        let one_t2 = one_t * one_t;
-
-        u + (a - u) * one_t2 + (b - u) * t * t
-      }
-
-      fn cubic_bezier(t: $t, a: Self, u: Self, v: Self, b: Self) -> Self {
-        let one_t = 1. - t;
-        let one_t2 = one_t * one_t;
-        let one_t3 = one_t2 * one_t;
-        let t2 = t * t;
-
-        a * one_t3 + (u * one_t2 * t + v * one_t * t2) * 3. + b * t2 * t
-      }
-
-      fn cubic_bezier_mirrored(t: $t, a: Self, u: Self, v: Self, b: Self) -> Self {
-        <Self as $crate::interpolate::Interpolate<$t>>::cubic_bezier(t, a, u, b + b - v, b)
+      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)
      }
    }
-  };
+  }
 }

-#[macro_export]
-macro_rules! impl_InterpolateT {
-  ($t:ty, $v:ty, $pi:expr) => {
-    impl $crate::interpolate::Interpolate<$t> for $v {
-      fn step(t: $t, threshold: $t, a: Self, b: Self) -> Self {
-        if t < threshold {
-          a
-        } else {
-          b
-        }
+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
      }

-      #[cfg(feature = "std")]
-      fn cosine(t: $t, a: Self, b: Self) -> Self {
-        let cos_nt = (1. - (t * $pi).cos()) * 0.5;
-        <Self as $crate::interpolate::Interpolate<$t>>::lerp(cos_nt, a, b)
-      }
-      #[cfg(not(feature = "std"))]
-      fn cosine(t: $t, a: Self, b: Self) -> Self {
-        unimplemented!()
-      }
-
-      fn lerp(t: $t, a: Self, b: Self) -> Self {
-        let t = Self::from(t);
-        a * (1. - t) + b * t
-      }
-
-      fn cubic_hermite(t: $t, x: ($t, Self), a: ($t, Self), b: ($t, Self), y: ($t, Self)) -> Self {
-        // sampler stuff
-        let t = Self::from(t);
-        let two_t = t * 2.;
-        let three_t = t * 3.;
-        let t2 = t * t;
-        let t3 = t2 * t;
-        let two_t3 = t2 * two_t;
-        let two_t2 = t * two_t;
-        let three_t2 = t * three_t;
-
-        // tangents
-        let m0 = (b.1 - x.1) / (Self::from(b.0 - x.0)) * (Self::from(b.0 - a.0));
-        let m1 = (y.1 - a.1) / (Self::from(y.0 - a.0)) * (Self::from(b.0 - a.0));
-
-        a.1 * (two_t3 - three_t2 + 1.)
-          + m0 * (t3 - two_t2 + t)
-          + b.1 * (three_t2 - two_t3)
-          + m1 * (t3 - t2)
-      }
-
-      fn quadratic_bezier(t: $t, a: Self, u: Self, b: Self) -> Self {
-        let t = Self::from(t);
-        let one_t = 1. - t;
-        let one_t2 = one_t * one_t;
-
-        u + (a - u) * one_t2 + (b - u) * t * t
-      }
-
-      fn cubic_bezier(t: $t, a: Self, u: Self, v: Self, b: Self) -> Self {
-        let t = Self::from(t);
-        let one_t = 1. - t;
-        let one_t2 = one_t * one_t;
-        let one_t3 = one_t2 * one_t;
-        let t2 = t * t;
-
-        a * one_t3 + (u * one_t2 * t + v * one_t * t2) * 3. + b * t2 * t
-      }
-
-      fn cubic_bezier_mirrored(t: $t, a: Self, u: Self, v: Self, b: Self) -> Self {
-        <Self as $crate::interpolate::Interpolate<$t>>::cubic_bezier(t, a, u, b + b - v, b)
+      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)
      }
    }
-  };
+  }
 }

-impl_Interpolate!(f32, f32, f32::consts::PI);
-impl_Interpolate!(f64, f64, f64::consts::PI);
-impl_InterpolateT!(f32, f64, f32::consts::PI);
+impl_interpolate_via!(f32, f64);
+impl_interpolate_via!(f64, f32);
--- a/src/interpolation.rs
+++ b/src/interpolation.rs
@ -1,20 +1,15 @@
 //! Available interpolation modes.

-#[cfg(any(feature = "serialization", feature = "serde"))]
-use serde::{Deserialize, Serialize};
+#[cfg(feature = "serialization")] use serde_derive::{Deserialize, Serialize};

 /// Available kind of interpolations.
 ///
 /// Feel free to visit each variant for more documentation.
-#[non_exhaustive]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-  any(feature = "serialization", feature = "serde"),
-  derive(Deserialize, Serialize),
-  serde(rename_all = "snake_case")
-)]
-pub enum Interpolation<T, V> {
-  /// Hold a [`Key`] until the sampling value passes the normalized step threshold, in which
+#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
+pub enum Interpolation<T> {
+  /// Hold a [`Key<T, _>`] 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
@ -22,51 +17,20 @@ pub enum Interpolation<T, V> {
  /// > 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
+  /// [`Key<T, _>`]: 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),
+  CatmullRom
 }

-impl<T, V> Default for Interpolation<T, V> {
+impl<T> Default for Interpolation<T> {
  /// [`Interpolation::Linear`] is the default.
  fn default() -> Self {
    Interpolation::Linear
  }
 }
+
--- a/src/iter.rs
+++ b/src/iter.rs
@ -11,13 +11,9 @@ 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,
-{
+pub struct Iter<'a, T, V> where T: 'a, V: 'a {
  spline: &'a Spline<T, V>,
-  i: usize,
+  i: usize
 }

 impl<'a, T, V> Iterator for Iter<'a, T, V> {
@ -39,6 +35,10 @@ impl<'a, T, V> IntoIterator for &'a Spline<T, V> {
  type IntoIter = Iter<'a, T, V>;

  fn into_iter(self) -> Self::IntoIter {
-    Iter { spline: self, i: 0 }
+    Iter {
+      spline: self,
+      i: 0
+    }
  }
 }
+
--- a/src/key.rs
+++ b/src/key.rs
@ -1,14 +1,14 @@
 //! Spline control points.
 //!
-//! A control point associates to a “sampling value” (a.k.a. time) a carried value that can be
+//! 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;
-#[cfg(any(feature = "serialization", feature = "serde"))]
-use serde::{Deserialize, Serialize};

 /// A spline control point.
 ///
@ -18,27 +18,20 @@ use serde::{Deserialize, Serialize};
 ///
 /// [`Interpolation`]: crate::interpolation::Interpolation
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-  any(feature = "serialization", feature = "serde"),
-  derive(Deserialize, Serialize),
-  serde(rename_all = "snake_case")
-)]
+#[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>,
+  pub interpolation: Interpolation<T>
 }

 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,
-    }
+  pub fn new(t: T, value: V, interpolation: Interpolation<T>) -> Self {
+    Key { t, value, interpolation }
  }
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@ -84,55 +84,34 @@
 //!
 //! So here’s a list of currently supported features and how to enable them:
 //!
-//!   - **Serde.**
-//!     - This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
+//!   - **Serialization / deserialization.**
+//!     + This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
 //!       types exported by this crate.
-//!     - Enable with the `"serde"` 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 `"cgmath"` feature.
-//!   - **[glam](https://crates.io/crates/glam) implementors.**
-//!     - Adds some useful implementations of `Interpolate` for some glam types.
-//!     - Enable with the `"glam"` 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 `"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.
-//!
-//! [`Interpolation`]: crate::interpolation::Interpolation
+//!     + 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.

 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]
 #![cfg_attr(not(feature = "std"), feature(core_intrinsics))]
-#![cfg_attr(
-  any(
-    feature = "impl-cgmath",
-    feature = "impl-glam",
-    feature = "impl-nalgebra"
-  ),
-  deprecated(
-    since = "4.2.0",
-    note = "you are using an impl-* feature gate; please switch to * (e.g. impl-cgmath becomes cgmath)"
-  )
-)]

-#[cfg(not(feature = "std"))]
-extern crate alloc;
+#[cfg(not(feature = "std"))] extern crate alloc;

-#[cfg(any(feature = "impl-cgmath", feature = "cgmath"))]
-mod cgmath;
-#[cfg(any(feature = "impl-glam", feature = "glam"))]
-mod glam;
+#[cfg(feature = "impl-cgmath")] mod cgmath;
 pub mod interpolate;
 pub mod interpolation;
 pub mod iter;
 pub mod key;
-#[cfg(any(feature = "impl-nalgebra", feature = "nalgebra"))]
-mod nalgebra;
+#[cfg(feature = "impl-nalgebra")] mod nalgebra;
 pub mod spline;

 pub use crate::interpolate::Interpolate;
--- a/src/nalgebra.rs
+++ b/src/nalgebra.rs
@ -1,27 +1,52 @@
-#[cfg(not(feature = "std"))]
-use core::f32;
-#[cfg(not(feature = "std"))]
-use core::f64;
-#[cfg(feature = "std")]
-use std::f32;
-#[cfg(feature = "std")]
-use std::f64;
+use alga::general::{ClosedAdd, ClosedDiv, ClosedMul, ClosedSub};
+use nalgebra::{Scalar, Vector, Vector1, Vector2, Vector3, Vector4, Vector5, Vector6};
+use num_traits as nt;
+use std::ops::Mul;

-use crate::impl_Interpolate;
-use nalgebra::{Quaternion, Vector1, Vector2, Vector3, Vector4, Vector5, Vector6};
+use crate::interpolate::{Interpolate, Linear, Additive, One, cubic_hermite_def};

-impl_Interpolate!(f32, Vector1<f32>, f32::consts::PI);
-impl_Interpolate!(f32, Vector2<f32>, f32::consts::PI);
-impl_Interpolate!(f32, Vector3<f32>, f32::consts::PI);
-impl_Interpolate!(f32, Vector4<f32>, f32::consts::PI);
-impl_Interpolate!(f32, Vector5<f32>, f32::consts::PI);
-impl_Interpolate!(f32, Vector6<f32>, f32::consts::PI);
-impl_Interpolate!(f32, Quaternion<f32>, f32::consts::PI);
+macro_rules! impl_interpolate_vector {
+  ($($t:tt)*) => {
+    // implement Linear
+    impl<T> Linear<T> for $($t)*<T> where T: Scalar + ClosedAdd + ClosedSub + ClosedMul + ClosedDiv {
+      #[inline(always)]
+      fn outer_mul(self, t: T) -> Self {
+        self * t
+      }

-impl_Interpolate!(f64, Vector1<f64>, f64::consts::PI);
-impl_Interpolate!(f64, Vector2<f64>, f64::consts::PI);
-impl_Interpolate!(f64, Vector3<f64>, f64::consts::PI);
-impl_Interpolate!(f64, Vector4<f64>, f64::consts::PI);
-impl_Interpolate!(f64, Vector5<f64>, f64::consts::PI);
-impl_Interpolate!(f64, Vector6<f64>, f64::consts::PI);
-impl_Interpolate!(f64, Quaternion<f64>, f64::consts::PI);
+      #[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)
+      }
+    }
+  }
+}
+
+impl_interpolate_vector!(Vector1);
+impl_interpolate_vector!(Vector2);
+impl_interpolate_vector!(Vector3);
+impl_interpolate_vector!(Vector4);
+impl_interpolate_vector!(Vector5);
+impl_interpolate_vector!(Vector6);
--- a/src/spline.rs
+++ b/src/spline.rs
@ -1,19 +1,15 @@
 //! Spline curves and operations.

-// #[cfg(feature = "std")]
-use crate::interpolate::{Interpolate, Interpolator};
+#[cfg(feature = "serialization")] use serde_derive::{Deserialize, Serialize};
+#[cfg(not(feature = "std"))] use alloc::vec::Vec;
+#[cfg(feature = "std")] use std::cmp::Ordering;
+#[cfg(feature = "std")] use std::ops::{Div, Mul};
+#[cfg(not(feature = "std"))] use core::ops::{Div, Mul};
+#[cfg(not(feature = "std"))] use core::cmp::Ordering;
+
+use crate::interpolate::{Interpolate, Additive, One, Trigo};
 use crate::interpolation::Interpolation;
 use crate::key::Key;
-#[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(any(feature = "serialization", feature = "serde"))]
-use serde::{Deserialize, Serialize};
-#[cfg(feature = "std")]
-use std::cmp::Ordering;

 /// Spline curve used to provide interpolation between control points (keys).
 ///
@ -27,42 +23,24 @@ use std::cmp::Ordering;
 ///     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, Default)]
-#[cfg_attr(
-  any(feature = "serialization", feature = "serde"),
-  derive(Deserialize, Serialize)
-)]
+#[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));
+  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,
-  {
+  pub fn from_vec(keys: Vec<Key<T, V>>) -> Self where T: PartialOrd {
    let mut spline = Spline(keys);
    spline.internal_sort();
    spline
  }

-  /// Clear the spline by removing all keys. Keeps the underlying allocated storage, so adding
-  /// new keys should be faster than creating a new [`Spline`]
-  #[inline]
-  pub fn clear(&mut self) {
-    self.0.clear()
-  }
-
  /// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
  /// sorted.
  ///
@ -70,11 +48,7 @@ impl<T, V> Spline<T, V> {
  ///
  /// 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,
-  {
+  pub fn from_iter<I>(iter: I) -> Self where I: Iterator<Item = Key<T, V>>, T: PartialOrd {
    Self::from_vec(iter.collect())
  }

@ -95,8 +69,7 @@ impl<T, V> Spline<T, V> {
    self.0.is_empty()
  }

-  /// Sample a spline at a given time, returning the interpolated value along with its associated
-  /// key.
+  /// 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)*
@ -110,38 +83,35 @@ impl<T, V> Spline<T, V> {
  /// 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<SampledWithKey<V>>
-  where
-    T: Interpolator,
-    V: Interpolate<T>,
-  {
+  ///
+  pub fn sample(&self, t: T) -> Option<V>
+  where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+        V: Interpolate<T> {
    let keys = &self.0;
    let i = search_lower_cp(keys, t)?;
    let cp0 = &keys[i];

-    let value = match cp0.interpolation {
+    match cp0.interpolation {
      Interpolation::Step(threshold) => {
-        let cp1 = &keys[i + 1];
-        let nt = t.normalize(cp0.t, cp1.t);
-        let value = V::step(nt, threshold, cp0.value, cp1.value);
-
-        Some(value)
+        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 = t.normalize(cp0.t, cp1.t);
-        let value = V::lerp(nt, cp0.value, cp1.value);
+        let cp1 = &keys[i+1];
+        let nt = normalize_time(t, cp0, cp1);

-        Some(value)
+        Some(Interpolate::lerp(cp0.value, cp1.value, nt))
      }

      Interpolation::Cosine => {
-        let cp1 = &keys[i + 1];
-        let nt = t.normalize(cp0.t, cp1.t);
-        let value = V::cosine(nt, cp0.value, cp1.value);
+        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;

-        Some(value)
+        Some(Interpolate::lerp(cp0.value, cp1.value, cos_nt))
      }

      Interpolation::CatmullRom => {
@ -150,54 +120,18 @@ impl<T, V> Spline<T, V> {
        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 = t.normalize(cp0.t, cp1.t);
-          let value = V::cubic_hermite(
-            nt,
-            (cpm0.t, cpm0.value),
-            (cp0.t, cp0.value),
-            (cp1.t, cp1.value),
-            (cpm1.t, cpm1.value),
-          );
+          let cp1 = &keys[i+1];
+          let cpm0 = &keys[i-1];
+          let cpm1 = &keys[i+2];
+          let nt = normalize_time(t, cp0, cp1);

-          Some(value)
+          Some(Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt))
        }
      }
-
-      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 = t.normalize(cp0.t, cp1.t);
-
-        let value = match cp1.interpolation {
-          Interpolation::Bezier(v) => V::cubic_bezier_mirrored(nt, cp0.value, u, v, cp1.value),
-
-          Interpolation::StrokeBezier(v, _) => V::cubic_bezier(nt, cp0.value, u, v, cp1.value),
-
-          _ => V::quadratic_bezier(nt, cp0.value, u, cp1.value),
-        };
-
-        Some(value)
-      }
-    };
-
-    value.map(|value| SampledWithKey { value, key: i })
+    }
  }

-  /// Sample a spline at a given time.
-  ///
-  pub fn sample(&self, t: T) -> Option<V>
-  where
-    T: Interpolator,
-    V: Interpolate<T>,
-  {
-    self.sample_with_key(t).map(|sampled| sampled.value)
-  }
-
-  /// Sample a spline at a given time with clamping, returning the interpolated value along with its
-  /// associated key.
+  /// Sample a spline at a given time with clamping.
  ///
  /// # Return
  ///
@ -207,33 +141,22 @@ impl<T, V> Spline<T, V> {
  /// # Error
  ///
  /// This function returns [`None`] if you have no key.
-  pub fn clamped_sample_with_key(&self, t: T) -> Option<SampledWithKey<V>>
-  where
-    T: Interpolator,
-    V: Interpolate<T>,
-  {
+  pub fn clamped_sample(&self, t: T) -> Option<V>
+  where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+        V: Interpolate<T> {
    if self.0.is_empty() {
      return None;
    }

-    self.sample_with_key(t).or_else(move || {
+    self.sample(t).or_else(move || {
      let first = self.0.first().unwrap();
-
      if t <= first.t {
-        let sampled = SampledWithKey {
-          value: first.value,
-          key: 0,
-        };
-        Some(sampled)
+        Some(first.value)
      } else {
        let last = self.0.last().unwrap();

        if t >= last.t {
-          let sampled = SampledWithKey {
-            value: last.value,
-            key: self.0.len() - 1,
-          };
-          Some(sampled)
+          Some(last.value)
        } else {
          None
        }
@ -241,20 +164,8 @@ impl<T, V> Spline<T, V> {
    })
  }

-  /// Sample a spline at a given time with clamping.
-  pub fn clamped_sample(&self, t: T) -> Option<V>
-  where
-    T: Interpolator,
-    V: Interpolate<T>,
-  {
-    self.clamped_sample_with_key(t).map(|sampled| sampled.value)
-  }
-
  /// Add a key into the spline.
-  pub fn add(&mut self, key: Key<T, V>)
-  where
-    T: PartialOrd,
-  {
+  pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
    self.0.push(key);
    self.internal_sort();
  }
@ -267,78 +178,48 @@ impl<T, V> Spline<T, V> {
      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 sampled value along with its key index.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct SampledWithKey<V> {
-  /// Sampled value.
-  pub value: V,
-
-  /// Key index.
-  pub key: usize,
-}
-
-/// 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`].
-#[derive(Debug)]
-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.
-// It has the property to have a timestamp smaller or equal to t
-fn search_lower_cp<T, V>(cps: &[Key<T, V>], t: T) -> Option<usize>
-where
-  T: PartialOrd,
-{
+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;
  }
-  match cps.binary_search_by(|key| key.t.partial_cmp(&t).unwrap()) {
-    Err(i) if i >= len => None,
-    Err(i) if i == 0 => None,
-    Err(i) => Some(i - 1),
-    Ok(i) if i == len - 1 => None,
-    Ok(i) => Some(i),
+
+  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)
 }
--- a/tests/cgmath.rs
+++ b/tests/cgmath.rs
@ -1,43 +0,0 @@
-#![cfg(feature = "cgmath")]
-
-use cgmath as cg;
-use splines::{Interpolation, Key, Spline};
-
-#[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(0., start, end), start);
-  assert_eq!(Interpolate::lerp(1., start, end), end);
-  assert_eq!(Interpolate::lerp(0.5, start, end), mid);
-}
-
-#[test]
-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.));
-}
--- a/tests/integ.rs
+++ b/tests/integ.rs
@ -1,4 +1,7 @@
-use splines::{spline::SampledWithKey, Interpolation, Key, Spline};
+use splines::{Interpolation, Key, Spline};
+
+#[cfg(feature = "impl-cgmath")] use cgmath as cg;
+#[cfg(feature = "impl-nalgebra")] use nalgebra as na;

 #[test]
 fn step_interpolation_f32() {
@ -13,14 +16,6 @@ fn step_interpolation_f32() {
  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(SampledWithKey { value: 10., key: 0 })
-  );
-  assert_eq!(
-    spline.clamped_sample_with_key(1.),
-    Some(SampledWithKey { value: 10., key: 1 })
-  );
 }

 #[test]
@ -36,14 +31,6 @@ fn step_interpolation_f64() {
  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(SampledWithKey { value: 10., key: 0 })
-  );
-  assert_eq!(
-    spline.clamped_sample_with_key(1.),
-    Some(SampledWithKey { value: 10., key: 1 })
-  );
 }

 #[test]
@ -158,6 +145,34 @@ fn several_interpolations_several_keys() {
  assert_eq!(spline.clamped_sample(11.), Some(4.));
 }

+#[cfg(feature = "impl-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")]
+#[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);
+
+  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);
+}
+
 #[test]
 fn add_key_empty() {
  let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]);
--- a/tests/nalgebra.rs
+++ b/tests/nalgebra.rs
@ -1,16 +0,0 @@
-#![cfg(feature = "nalgebra")]
-
-use nalgebra as na;
-
-#[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);
-
-  assert_eq!(Interpolate::lerp(0., start, end), start);
-  assert_eq!(Interpolate::lerp(1., start, end), end);
-  assert_eq!(Interpolate::lerp(0.5, start, end), mid);
-}