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()))
}

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, pair};  ← linearScale, another function of this group · built into the same file, even by a slim install
use super::math_ln::ln;  ← from math.ln ^1.0.0 · built alongside by fune
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// Where `value` lands on a logarithmic axis: equal ratios take equal lengths.
/// The base cancels out, so there is none to pass. `ln` is math.ln, not
/// `f64::ln`, so every language lands on the same double.
///
/// # Panics
/// Panics if the domain or range does not have two values, either domain end
/// is not positive, the ends are equal, or `value` is not positive.
pub fn log_scale(domain: &[f64], range: &[f64], value: f64, clamp: bool) -> f64 {
    let (d0, d1) = pair(domain, "domain");
    let (r0, r1) = pair(range, "range");
    if !(d0 > 0.0) || !(d1 > 0.0) {
        panic!("log scale domain must be positive; got [{}, {}]", d0, d1);
    }
    if d0 == d1 {
        panic!("domain has no width: both ends are {}", d0);
    }
    if !(value > 0.0) {
        panic!("value must be positive for a log scale; got {}", value);
    }
    let l0 = ln(d0);
    let mut t = (ln(value) - l0) / (ln(d1) - l0);
    if clamp {
        t = t.max(0.0).min(1.0);
    }
    round_float(interpolate(r0, r1, t), 6)
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Float(log_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, pair};  ← linearScale, another function of this group · built into the same file, even by a slim install
use super::dates_days_between::days_between;  ← from dates.days-between ^1.0.0 · built alongside by fune
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// Where an ISO date lands on the range, linearly by calendar days, counted
/// with dates.days-between so no time zone can move a point by a day.
///
/// # Panics
/// Panics if the domain or range does not have two values, a date is not a
/// real ISO date, or the domain's ends are the same day.
pub fn time_scale(domain: &[String], range: &[f64], value: &str, clamp: bool) -> f64 {
    if domain.len() != 2 {
        panic!("domain must have exactly 2 values, [from, to]; got {}", domain.len());
    }
    let (r0, r1) = pair(range, "range");
    let span = days_between(&domain[0], &domain[1]);
    if span == 0 {
        panic!("domain has no width: both ends are {}", domain[0]);
    }
    let mut t = days_between(&domain[0], value) as f64 / span as f64;
    if clamp {
        t = t.max(0.0).min(1.0);
    }
    round_float(interpolate(r0, r1, t), 6)
}

pub fn fune_vector(args: &[Value]) -> Value {
    let domain: Vec<String> = args[0].as_arr().iter().map(|v| v.as_str().to_string()).collect();
    Value::Float(time_scale(&domain, &floats(&args[1]), args[2].as_str(), 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, pair};  ← linearScale, another function of this group · built into the same file, even by a slim install
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// The band a category occupies, as d3.scaleBand lays it out (without
/// rounding to whole pixels). A reversed range reverses the order of the
/// bands, not their direction, so `start` is always the lower coordinate.
///
/// # Panics
/// Panics on an empty or repeating domain, a value not in it, a range without
/// two values, or padding or align out of bounds.
pub fn band_scale(domain: &[String], range: &[f64], value: &str, padding_inner: f64, padding_outer: f64, align: f64) -> Band {
    if !(padding_inner >= 0.0 && padding_inner <= 1.0) {
        panic!("paddingInner must be between 0 and 1; got {}", padding_inner);
    }
    check_outer(padding_outer, "paddingOuter");
    check_align(align);
    let (start, width) = band_position(domain, range, value, padding_inner, padding_outer, align);
    Band {
        start: round_float(start, 6),
        center: round_float(start + width / 2.0, 6),
        width: round_float(width, 6),
    }
}

// Exported for point_scale, which is a band scale whose bands have no width.

pub fn check_outer(padding: f64, what: &str) {
    if !(padding >= 0.0) {
        panic!("{} must be 0 or more; got {}", what, padding);
    }
}

pub fn check_align(align: f64) {
    if !(align >= 0.0 && align <= 1.0) {
        panic!("align must be between 0 and 1; got {}", align);
    }
}

/// The unrounded lower coordinate of value's band, and the band width.
pub fn band_position(domain: &[String], range: &[f64], value: &str, padding_inner: f64, padding_outer: f64, align: f64) -> (f64, f64) {
    let (r0, r1) = pair(range, "range");
    let n = domain.len();
    if n == 0 {
        panic!("domain must not be empty");
    }
    let mut index: Option<usize> = None;
    for i in 0..n {
        for j in 0..i {
            if domain[j] == domain[i] {
                panic!("domain has a repeated value: \"{}\"", domain[i]);
            }
        }
        if domain[i] == value {
            index = Some(i);
        }
    }
    let index = match index {
        Some(i) => i,
        None => panic!("value is not in the domain: \"{}\"", value),
    };
    let reverse = r1 < r0;
    let mut start = if reverse { r1 } else { r0 };
    let stop = if reverse { r0 } else { r1 };
    let nf = n as f64;
    let step = (stop - start) / (nf - padding_inner + padding_outer * 2.0).max(1.0);
    start += (stop - start - step * (nf - padding_inner)) * align;
    let slot = if reverse { n - 1 - index } else { index };
    (start + step * slot as f64, step * (1.0 - padding_inner))
}

pub fn band_to_value(band: &Band) -> Value {
    Value::obj(vec![
        ("start", Value::Float(band.start)),
        ("center", Value::Float(band.center)),
        ("width", Value::Float(band.width)),
    ])
}

/// A JSON list of strings, for the vector adapters.
pub fn band_strings(value: &Value) -> Vec<String> {
    value.as_arr().iter().map(|v| v.as_str().to_string()).collect()
}

pub fn fune_vector(args: &[Value]) -> Value {
    band_to_value(&band_scale(
        &band_strings(&args[0]),
        &floats(&args[1]),
        args[2].as_str(),
        args[3].as_f64(),
        args[4].as_f64(),
        args[5].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
use super::charts_scale_band_scale::{band_position, band_strings, check_align, check_outer};  ← bandScale, another function of this group · built into the same file, even by a slim install
use super::charts_scale_linear_scale::floats;  ← linearScale, another function of this group · built into the same file, even by a slim install
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// The position of a category on an axis of evenly spaced points, as
/// d3.scalePoint: a band scale with inner padding 1, so bands have no width.
///
/// # Panics
/// Panics on an empty or repeating domain, a value not in it, a range without
/// two values, or padding or align out of bounds.
pub fn point_scale(domain: &[String], range: &[f64], value: &str, padding: f64, align: f64) -> f64 {
    check_outer(padding, "padding");
    check_align(align);
    round_float(band_position(domain, range, value, 1.0, padding, align).0, 6)
}

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