charts.format

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::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune
use super::text_format_decimal::format_decimal;  ← from text.format-decimal ^1.0.0 · built alongside by fune

/// The fewest decimal places (0 to 12) that write x exactly; 12 if none do.
pub fn places_for(x: f64) -> i64 {
    let a = x.abs();
    for d in 0..12 {
        if round_float(a, d) == a {
            return d;
        }
    }
    12
}

/// A tick label with as many decimal places as the step needs, comma-grouped.
///
/// # Panics
/// Panics if the step is not finite or the value is too large to format.
pub fn format_tick(value: f64, step: f64) -> String {
    if !step.is_finite() {
        panic!("step must be a finite number, received {}", step);
    }
    let places = if step == 0.0 { places_for(value) } else { places_for(step) };
    format_decimal(value, places, false, ",")
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&format_tick(args[0].as_f64(), args[1].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::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune
use super::text_format_decimal::format_decimal;  ← from text.format-decimal ^1.0.0 · built alongside by fune

// yocto to yotta, as d3-format writes them (micro is U+00B5).
const PREFIXES: [&str; 17] = ["y", "z", "a", "f", "p", "n", "\u{b5}", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
const THOUSANDS: [f64; 9] = [1.0, 1e3, 1e6, 1e9, 1e12, 1e15, 1e18, 1e21, 1e24];
const TENS: [f64; 3] = [1.0, 10.0, 100.0];

fn scale_and_round(value: f64, group: i64, places: i64) -> (f64, i64) {
    let scaled = if group >= 0 { value / THOUSANDS[group as usize] } else { value * THOUSANDS[(-group) as usize] };
    if places < 0 {
        let unit = TENS[(-places) as usize];
        return (round_float(scaled / unit, 0) * unit, 0);
    }
    let p = if places > 12 { 12 } else { places };
    (round_float(scaled, p), p)
}

/// A number with an SI prefix and `significant` significant digits, trailing
/// zeros dropped: 1200 is "1.2k", 0.0015 is "1.5m".
///
/// # Panics
/// Panics if `significant` is outside 1..=15 or the value is not finite.
pub fn format_si(value: f64, significant: i64) -> String {
    if !(1..=15).contains(&significant) {
        panic!("significant must be a whole number from 1 to 15, received {}", significant);
    }
    if !value.is_finite() {
        panic!("value must be a finite number, received {}", value);
    }
    if value == 0.0 {
        return "0".to_string();
    }
    let a = value.abs();
    let mut exponent: i64 = 0;
    if a >= 1.0 {
        let mut p = 1.0;
        while p * 10.0 <= a {
            p *= 10.0;
            exponent += 1;
        }
    } else {
        let mut q = 1.0;
        while a * q < 1.0 {
            q *= 10.0;
            exponent -= 1;
        }
    }
    let group = exponent.div_euclid(3).clamp(-8, 8);
    let (mut rounded, mut places) = scale_and_round(value, group, significant - 1 - (exponent - 3 * group));
    let mut group = group;
    if rounded.abs() >= 1000.0 && group < 8 {
        group += 1;
        let next = scale_and_round(value, group, significant - 1);
        rounded = next.0;
        places = next.1;
    }
    format!("{}{}", format_decimal(rounded, places, true, ""), PREFIXES[(group + 8) as usize])
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&format_si(args[0].as_f64(), 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::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune
use super::text_format_decimal::format_decimal;  ← from text.format-decimal ^1.0.0 · built alongside by fune

/// A fraction as a percentage with fixed places; the product is cleaned of
/// binary noise at 12 places first, so 0.145 is "15%", not "14%".
///
/// # Panics
/// Panics if the value is not finite or `decimals` is outside 0..=12.
pub fn format_percent(value: f64, decimals: i64) -> String {
    if !value.is_finite() {
        panic!("value must be a finite number, received {}", value);
    }
    let percent = round_float(value * 100.0, 12);
    format!("{}%", format_decimal(percent, decimals, false, ""))
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&format_percent(args[0].as_f64(), 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::dates_add_days::parse_iso_date;  ← from dates.add-days ^1.0.0 · built alongside by fune

const MONTHS: [&str; 12] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

/// A date as a tick label for the interval it stands for.
///
/// # Panics
/// Panics on an invalid date or an unknown label.
pub fn format_date(iso: &str, label: &str) -> String {
    let date = parse_iso_date(iso);
    let year = &iso[0..4];
    let month = MONTHS[(date.month - 1) as usize];
    match label {
        "day" | "week" => format!("{} {}", date.day, month),
        "month" => format!("{} {}", month, year),
        "quarter" => format!("Q{} {}", (date.month - 1) / 3 + 1, year),
        "year" => year.to_string(),
        other => panic!("unknown date label \"{}\"; use day, week, month, quarter or year", other),
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&format_date(args[0].as_str(), args[1].as_str()))
}

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::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune
use super::money_amount::money;  ← from money.amount ^1.0.0 · built alongside by fune
use super::money_format::format_money;  ← from money.format ^1.0.0 · built alongside by fune

/// A money-axis tick: rounded half away from zero to a whole minor unit, then
/// printed by money.format.
///
/// # Panics
/// Panics if `minor` is not finite or the currency is unknown.
pub fn format_money_tick(minor: f64, currency: &str) -> String {
    if !minor.is_finite() {
        panic!("minor must be a finite number, received {}", minor);
    }
    format_money(&money(round_float(minor, 0) as i64, currency))
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&format_money_tick(args[0].as_f64(), args[1].as_str()))
}