#[inline]
pub fn inverse_lerp(v: f32, a: f32, b: f32) -> f32 {
if (b - a).abs() < f32::EPSILON {
0.0
} else {
(v - a) / (b - a)
}
}
#[inline]
pub fn lerp(a: f32, b: f32, t: f32) -> f32 {
a + (b - a) * t
}
#[inline]
pub fn map_range(v: f32, in_lo: f32, in_hi: f32, out_lo: f32, out_hi: f32) -> f32 {
lerp(out_lo, out_hi, inverse_lerp(v, in_lo, in_hi))
}
#[inline]
pub fn map_range_clamped(v: f32, in_lo: f32, in_hi: f32, out_lo: f32, out_hi: f32) -> f32 {
let out = map_range(v, in_lo, in_hi, out_lo, out_hi);
if out_lo <= out_hi {
out.clamp(out_lo, out_hi)
} else {
out.clamp(out_hi, out_lo)
}
}
#[inline]
pub fn smoothstep(e0: f32, e1: f32, x: f32) -> f32 {
let t = inverse_lerp(x, e0, e1).clamp(0.0, 1.0);
t * t * (3.0 - 2.0 * t)
}
#[inline]
pub fn smootherstep(e0: f32, e1: f32, x: f32) -> f32 {
let t = inverse_lerp(x, e0, e1).clamp(0.0, 1.0);
t * t * t * (t * (t * 6.0 - 15.0) + 10.0)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
enum Clamping {
#[default]
Extrapolate,
Clamp,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ScaleLinear {
domain: [f32; 2],
range: [f32; 2],
clamping: Clamping,
}
impl ScaleLinear {
pub fn new(domain: [f32; 2], range: [f32; 2]) -> Self {
Self {
domain,
range,
clamping: Clamping::Extrapolate,
}
}
pub fn clamped(mut self) -> Self {
self.clamping = Clamping::Clamp;
self
}
pub fn get(&self, v: f32) -> f32 {
match self.clamping {
Clamping::Extrapolate => {
map_range(v, self.domain[0], self.domain[1], self.range[0], self.range[1])
}
Clamping::Clamp => map_range_clamped(
v,
self.domain[0],
self.domain[1],
self.range[0],
self.range[1],
),
}
}
pub fn invert(&self, v: f32) -> f32 {
map_range(v, self.range[0], self.range[1], self.domain[0], self.domain[1])
}
pub fn domain(&self) -> [f32; 2] {
self.domain
}
pub fn range(&self) -> [f32; 2] {
self.range
}
pub fn nice(mut self, count: usize) -> Self {
let step = tick_step(self.domain[0], self.domain[1], count);
if step > 0.0 && step.is_finite() {
let (lo, hi) = (self.domain[0].min(self.domain[1]), self.domain[0].max(self.domain[1]));
let (nlo, nhi) = ((lo / step).floor() * step, (hi / step).ceil() * step);
self.domain = if self.domain[0] <= self.domain[1] {
[nlo, nhi]
} else {
[nhi, nlo]
};
}
self
}
pub fn ticks(&self, count: usize) -> Vec<f32> {
ticks(self.domain[0], self.domain[1], count)
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ScaleLog {
domain: [f32; 2],
range: [f32; 2],
clamping: Clamping,
}
impl ScaleLog {
pub fn new(domain: [f32; 2], range: [f32; 2]) -> Option<Self> {
if domain[0] == 0.0 || domain[1] == 0.0 || domain[0].signum() != domain[1].signum() {
return None;
}
Some(Self {
domain,
range,
clamping: Clamping::Extrapolate,
})
}
pub fn clamped(mut self) -> Self {
self.clamping = Clamping::Clamp;
self
}
pub fn get(&self, v: f32) -> f32 {
let sign = self.domain[0].signum();
let (a, b, x) = (
(self.domain[0] * sign).ln(),
(self.domain[1] * sign).ln(),
(v * sign).max(f32::MIN_POSITIVE).ln(),
);
match self.clamping {
Clamping::Extrapolate => map_range(x, a, b, self.range[0], self.range[1]),
Clamping::Clamp => map_range_clamped(x, a, b, self.range[0], self.range[1]),
}
}
pub fn invert(&self, v: f32) -> f32 {
let sign = self.domain[0].signum();
let (a, b) = ((self.domain[0] * sign).ln(), (self.domain[1] * sign).ln());
map_range(v, self.range[0], self.range[1], a, b).exp() * sign
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ScalePow {
domain: [f32; 2],
range: [f32; 2],
exponent: f32,
clamping: Clamping,
}
impl ScalePow {
pub fn new(domain: [f32; 2], range: [f32; 2], exponent: f32) -> Self {
Self {
domain,
range,
exponent,
clamping: Clamping::Extrapolate,
}
}
pub fn clamped(mut self) -> Self {
self.clamping = Clamping::Clamp;
self
}
pub fn get(&self, v: f32) -> f32 {
let p = |x: f32| x.abs().powf(self.exponent) * x.signum();
let t = inverse_lerp(p(v), p(self.domain[0]), p(self.domain[1]));
let out = lerp(self.range[0], self.range[1], t);
match self.clamping {
Clamping::Extrapolate => out,
Clamping::Clamp => {
if self.range[0] <= self.range[1] {
out.clamp(self.range[0], self.range[1])
} else {
out.clamp(self.range[1], self.range[0])
}
}
}
}
}
pub fn tick_step(lo: f32, hi: f32, count: usize) -> f32 {
let count = count.max(1) as f32;
let span = (hi - lo).abs();
if span == 0.0 || !span.is_finite() {
return 0.0;
}
let raw = span / count;
let power = raw.log10().floor();
let base = 10f32.powf(power);
let err = raw / base;
base * if err >= 7.071 {
10.0
} else if err >= 3.162 {
5.0
} else if err >= 1.414 {
2.0
} else {
1.0
}
}
pub fn ticks(lo: f32, hi: f32, count: usize) -> Vec<f32> {
let step = tick_step(lo, hi, count);
if step <= 0.0 || !step.is_finite() {
return Vec::new();
}
let (a, b) = (lo.min(hi), lo.max(hi));
let first = (a / step).ceil() as i64;
let last = (b / step).floor() as i64;
if last < first {
return Vec::new();
}
let mut out: Vec<f32> = (first..=last).map(|i| i as f32 * step).collect();
if lo > hi {
out.reverse();
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn map_range_matches_the_arithmetic_it_replaces() {
assert_eq!(map_range(5.0, 0.0, 10.0, 0.0, 100.0), 50.0);
assert_eq!(map_range(0.0, 0.0, 10.0, 20.0, 30.0), 20.0);
assert_eq!(map_range(10.0, 0.0, 10.0, 20.0, 30.0), 30.0);
assert_eq!(map_range(20.0, 0.0, 10.0, 0.0, 100.0), 200.0);
assert_eq!(map_range(0.25, 0.0, 1.0, 1.0, 0.0), 0.75);
}
#[test]
fn a_zero_width_domain_does_not_produce_nan() {
let v = map_range(5.0, 3.0, 3.0, 0.0, 100.0);
assert!(v.is_finite(), "got {v}");
assert_eq!(v, 0.0);
assert_eq!(inverse_lerp(5.0, 3.0, 3.0), 0.0);
}
#[test]
fn clamping_handles_a_reversed_output_range() {
assert_eq!(map_range_clamped(2.0, 0.0, 1.0, 1.0, 0.0), 0.0);
assert_eq!(map_range_clamped(-1.0, 0.0, 1.0, 1.0, 0.0), 1.0);
assert_eq!(map_range_clamped(5.0, 0.0, 10.0, 0.0, 100.0), 50.0);
}
#[test]
fn a_linear_scale_inverts_itself() {
let s = ScaleLinear::new([0.0, 100.0], [0.0, 640.0]);
for v in [0.0f32, 1.0, 33.3, 99.9, 100.0] {
assert!((s.invert(s.get(v)) - v).abs() < 1e-3, "round trip at {v}");
}
assert_eq!(s.clamped().get(200.0), 640.0);
assert_eq!(s.get(200.0), 1280.0, "unclamped by default, as in d3");
}
#[test]
fn a_log_scale_spaces_decades_evenly() {
let s = ScaleLog::new([1.0, 1000.0], [0.0, 3.0]).expect("valid domain");
assert!((s.get(1.0) - 0.0).abs() < 1e-4);
assert!((s.get(10.0) - 1.0).abs() < 1e-4);
assert!((s.get(100.0) - 2.0).abs() < 1e-4);
assert!((s.get(1000.0) - 3.0).abs() < 1e-4);
assert!((s.invert(2.0) - 100.0).abs() < 1e-2);
assert!(ScaleLog::new([0.0, 10.0], [0.0, 1.0]).is_none());
assert!(ScaleLog::new([-1.0, 10.0], [0.0, 1.0]).is_none());
}
#[test]
fn a_sqrt_scale_encodes_area_rather_than_radius() {
let s = ScalePow::new([0.0, 100.0], [0.0, 10.0], 0.5);
let r_small = s.get(25.0);
let r_big = s.get(100.0);
assert!((r_big / r_small - 2.0).abs() < 1e-4, "radius should double");
let area_ratio = (r_big * r_big) / (r_small * r_small);
assert!((area_ratio - 4.0).abs() < 1e-3, "area should quadruple");
}
#[test]
fn ticks_land_on_round_numbers() {
assert_eq!(ticks(0.0, 10.0, 5), vec![0.0, 2.0, 4.0, 6.0, 8.0, 10.0]);
let fine = ticks(0.0, 1.0, 5);
assert_eq!(fine.len(), 6);
for (got, want) in fine.iter().zip([0.0f32, 0.2, 0.4, 0.6, 0.8, 1.0]) {
assert!((got - want).abs() < 1e-5, "{got} is not about {want}");
}
let down = ticks(10.0, 0.0, 5);
assert_eq!(down.first(), Some(&10.0));
assert_eq!(down.last(), Some(&0.0));
assert!(ticks(3.0, 3.0, 5).is_empty());
}
#[test]
fn nice_rounds_the_domain_outwards() {
let s = ScaleLinear::new([0.3, 9.4], [0.0, 1.0]).nice(5);
let [lo, hi] = s.domain();
assert!(lo <= 0.3 && hi >= 9.4, "nice must not shrink the domain");
assert_eq!([lo, hi], [0.0, 10.0]);
}
#[test]
fn smootherstep_is_flatter_at_the_ends_than_smoothstep() {
let d = 1e-3;
let slope = |f: fn(f32, f32, f32) -> f32| (f(0.0, 1.0, d) - f(0.0, 1.0, 0.0)) / d;
assert!(
slope(smootherstep) < slope(smoothstep),
"smootherstep should leave 0 more gently"
);
for f in [smoothstep as fn(f32, f32, f32) -> f32, smootherstep] {
assert_eq!(f(0.0, 1.0, -1.0), 0.0);
assert_eq!(f(0.0, 1.0, 2.0), 1.0);
assert!((f(0.0, 1.0, 0.5) - 0.5).abs() < 1e-6);
}
}
}