charts.ticks

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

/// The tick step for about `count` ticks: 1, 2 or 5 times a power of ten, as
/// d3-array's tickIncrement chooses it, found without log10 and returned as one
/// correctly rounded division so 0.2 is exactly the double 0.2.
///
/// # Panics
/// Panics if start or stop is not finite or `count` is less than 1.
pub fn tick_step(start: f64, stop: f64, count: i64) -> f64 {
    let (mul, div) = tick_spec(start, stop, count);
    mul / div
}

// Exported for nice_ticks, which needs the step as a multiplier or a divisor.

/// The step as (multiplier, divisor), one of which is 1; (0, 1) when start
/// equals stop.
pub fn tick_spec(start: f64, stop: f64, count: i64) -> (f64, f64) {
    if !start.is_finite() || !stop.is_finite() {
        panic!("start and stop must be finite numbers; got {} and {}", start, stop);
    }
    if count < 1 {
        panic!("count must be a whole number of at least 1, got {}", count);
    }
    let raw = (stop - start).abs() / count as f64;
    if raw == 0.0 {
        return (0.0, 1.0);
    }
    if raw >= 1.0 {
        let mut power = 1.0;
        while power * 10.0 <= raw {
            power *= 10.0;
        }
        return (nice_factor(raw / power) * power, 1.0);
    }
    let mut inverse = 1.0;
    while raw * inverse < 1.0 {
        inverse *= 10.0;
    }
    let factor = nice_factor(raw * inverse);
    if factor == inverse {
        (1.0, 1.0)
    } else {
        (1.0, inverse / factor)
    }
}

fn nice_factor(error: f64) -> f64 {
    if error >= 50f64.sqrt() {
        10.0
    } else if error >= 10f64.sqrt() {
        5.0
    } else if error >= 2f64.sqrt() {
        2.0
    } else {
        1.0
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    // Refuse what the typed signature cannot hold, with the wording TypeScript
    // and Python use, rather than let the conversion below quietly change it.
    if matches!(args[2], Value::Float(f) if f.fract() != 0.0) {
        panic!("count must be a whole number of at least 1");
    }
    Value::Float(tick_step(args[0].as_f64(), args[1].as_f64(), args[2].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_ticks_tick_step::tick_spec;  ← tickStep, 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

/// Ticks at round values between start and stop, as d3.ticks, each one exact
/// operation on a whole number (i * step or i / divisor), so 0.1 steps give 0.3
/// and not 0.30000000000000004.
///
/// # Panics
/// Panics if start or stop is not finite or `count` is less than 1.
pub fn nice_ticks(start: f64, stop: f64, count: i64) -> Vec<f64> {
    let (mut mul, mut div) = tick_spec(start, stop, count);
    if start == stop {
        return vec![start + 0.0];
    }
    let reverse = stop < start;
    let (lo, hi) = if reverse { (stop, start) } else { (start, stop) };
    let (mut i1, mut i2) = indexes(lo, hi, mul, div);
    if i2 < i1 && count == 1 {
        // No multiple of the step for one tick falls inside; d3 retries with two.
        let spec = tick_spec(start, stop, 2);
        mul = spec.0;
        div = spec.1;
        let idx = indexes(lo, hi, mul, div);
        i1 = idx.0;
        i2 = idx.1;
    }
    let mut ticks = Vec::new();
    let mut i = i1;
    while i <= i2 {
        ticks.push((if div > 1.0 { i / div } else { i * mul }) + 0.0);
        i += 1.0;
    }
    if reverse {
        ticks.reverse();
    }
    ticks
}

fn indexes(lo: f64, hi: f64, mul: f64, div: f64) -> (f64, f64) {
    if div > 1.0 {
        let mut i1 = round_float(lo * div, 0);
        let mut i2 = round_float(hi * div, 0);
        if i1 / div < lo {
            i1 += 1.0;
        }
        if i2 / div > hi {
            i2 -= 1.0;
        }
        return (i1, i2);
    }
    let mut i1 = round_float(lo / mul, 0);
    let mut i2 = round_float(hi / mul, 0);
    if i1 * mul < lo {
        i1 += 1.0;
    }
    if i2 * mul > hi {
        i2 -= 1.0;
    }
    (i1, i2)
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Arr(
        nice_ticks(args[0].as_f64(), args[1].as_f64(), args[2].as_i64())
            .into_iter()
            .map(Value::Float)
            .collect(),
    )
}

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_ticks_tick_step::tick_step;  ← tickStep, another function of this group · built into the same file, even by a slim install
use super::dates_add_days::epoch_day_from_iso;  ← from dates.add-days ^1.0.0 · built alongside by fune

// d3-scale's calendar ladder, from a day up, with the lengths in days it
// compares against: a month counts as 30, a quarter as 90, a year as 365.
const LADDER: [(&str, i64, f64); 6] = [
    ("day", 1, 1.0),
    ("day", 2, 2.0),
    ("week", 1, 7.0),
    ("month", 1, 30.0),
    ("quarter", 1, 90.0),
    ("year", 1, 365.0),
];

/// The calendar interval for about `count` ticks between two dates, as d3's
/// time scale picks it: the nearest rung of the ladder by ratio, or whole years
/// in steps of 1, 2 or 5 x 10^k beyond a year.
///
/// # Panics
/// Panics on a date that is not a real ISO date or `count` less than 1.
pub fn time_tick_interval(start: &str, stop: &str, count: i64) -> TimeTickInterval {
    if count < 1 {
        panic!("count must be a whole number of at least 1, got {}", count);
    }
    let span = (epoch_day_from_iso(stop) - epoch_day_from_iso(start)).abs() as f64;
    let target = span / count as f64;
    let mut i = 0;
    while i < LADDER.len() && LADDER[i].2 <= target {
        i += 1;
    }
    if i == LADDER.len() {
        let step = tick_step(0.0, span / 365.0, count) as i64;
        return TimeTickInterval { interval: "year".to_string(), step: step.max(1) };
    }
    if i == 0 {
        return TimeTickInterval { interval: "day".to_string(), step: 1 };
    }
    let pick = if target / LADDER[i - 1].2 < LADDER[i].2 / target { LADDER[i - 1] } else { LADDER[i] };
    TimeTickInterval { interval: pick.0.to_string(), step: pick.1 }
}

pub fn time_tick_interval_to_value(t: &TimeTickInterval) -> Value {
    Value::obj(vec![("interval", Value::str(&t.interval)), ("step", Value::Int(t.step))])
}

pub fn fune_vector(args: &[Value]) -> Value {
    time_tick_interval_to_value(&time_tick_interval(args[0].as_str(), args[1].as_str(), args[2].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::dates_add_days::{civil_from_days, days_from_civil, epoch_day_from_iso, iso_from_epoch_day};  ← from dates.add-days ^1.0.0 · built alongside by fune

// 1970-01-05, the first Monday on or after the epoch, as a day number.
const FIRST_MONDAY: i64 = 4;
const MAX_TICKS: usize = 10000;

fn ceil_div(a: i64, b: i64) -> i64 {
    -((-a).div_euclid(b))
}

/// Calendar boundaries between two dates, inclusive, anchored to the calendar
/// rather than to `start` so that panning does not move them: days by
/// (day - 1) % step, weeks since 1970-01-05, months by (month - 1) % step,
/// quarters by quarter of the year, years by year % step.
///
/// # Panics
/// Panics on a date that is not a real ISO date, an unknown interval, `step`
/// less than 1, or more than 10,000 ticks.
pub fn time_ticks(start: &str, stop: &str, interval: &str, step: i64) -> Vec<String> {
    if step < 1 {
        panic!("step must be a whole number of at least 1, got {}", step);
    }
    let a = epoch_day_from_iso(start);
    let b = epoch_day_from_iso(stop);
    let reverse = b < a;
    let (lo, hi) = if reverse { (b, a) } else { (a, b) };
    let mut days: Vec<i64> = Vec::new();
    let add = |day: i64, days: &mut Vec<i64>| {
        if days.len() >= MAX_TICKS {
            panic!("too many ticks: more than {}; use a longer interval or step", MAX_TICKS);
        }
        days.push(day);
    };

    match interval {
        "day" => {
            for d in lo..=hi {
                if (civil_from_days(d).day - 1) % step == 0 {
                    add(d, &mut days);
                }
            }
        }
        "week" => {
            let mut k = ceil_div(lo - FIRST_MONDAY, 7);
            k = ceil_div(k, step) * step;
            let mut d = FIRST_MONDAY + 7 * k;
            while d <= hi {
                add(d, &mut days);
                d += 7 * step;
            }
        }
        "month" | "quarter" | "year" => {
            let months = match interval {
                "month" => step,
                "quarter" => 3 * step,
                _ => 12,
            };
            let first = civil_from_days(lo);
            let (mut year, mut month) = (first.year, first.month);
            loop {
                let d = days_from_civil(year, month, 1);
                if d > hi {
                    break;
                }
                let on_step = if interval == "year" {
                    month == 1 && year % step == 0
                } else {
                    (month - 1) % months == 0
                };
                if d >= lo && on_step {
                    add(d, &mut days);
                }
                month += 1;
                if month > 12 {
                    month = 1;
                    year += 1;
                }
            }
        }
        other => panic!("unknown time interval \"{}\"", other),
    }
    let mut ticks: Vec<String> = days.into_iter().map(iso_from_epoch_day).collect();
    if reverse {
        ticks.reverse();
    }
    ticks
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Arr(
        time_ticks(args[0].as_str(), args[1].as_str(), args[2].as_str(), args[3].as_i64())
            .iter()
            .map(|s| Value::str(s))
            .collect(),
    )
}