charts.scale

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

/// Where `value` lands on the range, as a straight-line map from the domain.
/// Outside the domain the line carries on, unless `clamp` stops it at the
/// range's ends.
///
/// # Panics
/// Panics if the domain or range does not have exactly two values, or the
/// domain's ends are equal.
pub fn linear_scale(domain: &[f64], range: &[f64], value: f64, clamp: bool) -> f64 {
    let (d0, d1) = pair(domain, "domain");
    let (r0, r1) = pair(range, "range");
    let mut t = normalise(d0, d1, value, "domain");
    if clamp {
        t = t.max(0.0).min(1.0);
    }
    round6(interpolate(r0, r1, t))
}

// The helpers below are shared with invert_linear, which is the same line read
// the other way; they are not part of the group's contract.

pub fn pair(values: &[f64], what: &str) -> (f64, f64) {
    if values.len() != 2 {
        panic!("{} must have exactly 2 values, [from, to]; got {}", what, values.len());
    }
    (values[0], values[1])
}

pub fn normalise(from: f64, to: f64, value: f64, what: &str) -> f64 {
    // Equal ends would divide by zero and answer NaN or infinity, which then
    // draws nothing without saying why.
    if from == to {
        panic!("{} has no width: both ends are {}", what, from);
    }
    (value - from) / (to - from)
}

pub fn interpolate(from: f64, to: f64, t: f64) -> f64 {
    from + t * (to - from)
}

/// Half up to 6 decimal places, the same way in every language.
pub fn round6(x: f64) -> f64 {
    (x * 1e6 + 0.5).floor() / 1e6
}

/// A JSON list of numbers, for the vector adapters.
pub fn floats(value: &Value) -> Vec<f64> {
    value.as_arr().iter().map(|v| v.as_f64()).collect()
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Float(linear_scale(
        &floats(&args[0]),
        &floats(&args[1]),
        args[2].as_f64(),
        args[3].as_bool(),
    ))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::charts_scale_linear_scale::{floats, interpolate, normalise, pair, round6};  ← linearScale, another function of this group · built into the same file, even by a slim install

/// The domain value at a position in the range: linear_scale read backwards.
/// Never clamped; a position past the end of the axis is a value past the end
/// of the data.
///
/// # Panics
/// Panics if the domain or range does not have exactly two values, or the
/// range's ends are equal.
pub fn invert_linear(domain: &[f64], range: &[f64], value: f64) -> f64 {
    let (d0, d1) = pair(domain, "domain");
    let (r0, r1) = pair(range, "range");
    round6(interpolate(d0, d1, normalise(r0, r1, value, "range")))
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Float(invert_linear(&floats(&args[0]), &floats(&args[1]), args[2].as_f64()))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

/// Widen a domain to multiples of a round tick step (1, 2 or 5 times a power
/// of ten) chosen for about `count` ticks. Widening can change the best step,
/// so it repeats until the step settles, as d3's nice() does.
///
/// # Panics
/// Panics if the domain does not have exactly two values or `count` is less
/// than 1.
pub fn nice_domain(domain: &[f64], count: i64) -> NiceDomain {
    if domain.len() != 2 {
        panic!("domain must have exactly 2 values, [from, to]; got {}", domain.len());
    }
    if count < 1 {
        panic!("count must be a whole number of at least 1, got {}", count);
    }
    let reversed = domain[1] < domain[0];
    let (mut lo, mut hi) = if reversed { (domain[1], domain[0]) } else { (domain[0], domain[1]) };
    if lo == hi {
        return NiceDomain { domain: vec![domain[0], domain[1]], step: 0.0 };
    }

    let mut step = 0.0;
    for _ in 0..10 {
        let next = tick_step(lo, hi, count as f64);
        if next == step {
            break;
        }
        step = next;
        if step >= 1.0 {
            lo = (lo / step).floor() * step;
            hi = (hi / step).ceil() * step;
        } else {
            // A fractional step divides badly (0.3 / 0.1 is 2.9999999999999996),
            // so multiply by its whole-number inverse instead.
            let inverse = (1.0 / step + 0.5).floor();
            lo = (lo * inverse).floor() / inverse;
            hi = (hi * inverse).ceil() / inverse;
        }
    }
    let ends = if reversed { vec![round6(hi), round6(lo)] } else { vec![round6(lo), round6(hi)] };
    NiceDomain { domain: ends, step: round6(step) }
}

fn tick_step(lo: f64, hi: f64, count: f64) -> f64 {
    let raw = (hi - lo) / count;
    // Powers of ten by repeated multiplication rather than log10, whose last
    // digit is not guaranteed to agree between languages.
    let mut power = 1.0;
    while power * 10.0 <= raw {
        power *= 10.0;
    }
    while power > raw {
        power /= 10.0;
    }
    let error = raw / power;
    let factor = if error >= 50f64.sqrt() {
        10.0
    } else if error >= 10f64.sqrt() {
        5.0
    } else if error >= 2f64.sqrt() {
        2.0
    } else {
        1.0
    };
    factor * power
}

fn round6(x: f64) -> f64 {
    (x * 1e6 + 0.5).floor() / 1e6
}

pub fn nice_domain_to_value(nice: &NiceDomain) -> Value {
    Value::obj(vec![
        ("domain", Value::Arr(nice.domain.iter().map(|x| Value::Float(*x)).collect())),
        ("step", Value::Float(nice.step)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    let domain: Vec<f64> = args[0].as_arr().iter().map(|v| v.as_f64()).collect();
    nice_domain_to_value(&nice_domain(&domain, args[1].as_i64()))
}