The gallery

use malevich::{Frame, Line, Plot};
include!("support/svg_card.rs");

fn main() {
    let plot = Plot::new()
        .layer(Line::function(0.0..12.6, f64::sin))
        .layer(Line::function(0.0..12.6, |x| (x * 0.5).cos() * 0.6))
        .title("sin(x) and 0.6 cos(x/2)");
    let frame = Frame::plain(72, 16);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::Frame;
include!("support/svg_card.rs");

fn main() {
    let chart = malevich::bar(
        ["rust", "go", "python", "typescript", "zig"],
        &[68.0, 41.0, 55.0, 62.0, 12.0][..],
    )
    .title("admired languages, % (synthetic)");
    let frame = Frame::plain(56, 14);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

use malevich::Frame;
include!("support/svg_card.rs");

fn main() {
    let mass: Vec<f64> = include_str!("data/penguins.csv")
        .lines()
        .skip(1)
        .filter_map(|line| line.split(',').nth(4)?.parse().ok())
        .collect();
    let chart = malevich::hist(&mass[..])
        .title("penguin body mass")
        .x_label("grams");
    let frame = Frame::plain(64, 15);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

use malevich::{Frame, Line, Plot, Rule, Text};
include!("support/svg_card.rs");

fn main() {
    let loss: Vec<f64> = (0..70)
        .map(|i| 4.0 * (-0.06 * i as f64).exp() + 0.4)
        .collect();
    let plot = Plot::new()
        .layer(Rule::v_span(0.0, 10.0).label("warm-up"))
        .layer(Line::y(&loss[..]).label("loss"))
        .layer(Rule::h(0.5).label("target"))
        .layer(Text::at(34.0, 2.2, "< converging"))
        .title("annotated loss (synthetic)");
    let frame = Frame::plain(60, 14);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{DescribeOptions, Frame};
include!("support/svg_card.rs");

fn main() {
    let (species, groups) = penguin_flippers();
    let refs: Vec<&[f64]> = groups.iter().map(Vec::as_slice).collect();
    // Three rows plus title, axis line, and headers — the tight-table height,
    // so every species lands on a consecutive line.
    let chart = malevich::describe_with(species, refs, DescribeOptions::new().histogram(8))
        .expect("one name per group")
        .title("flipper length by species (mm)");
    let frame = Frame::plain(96, 6);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render(&frame));
}

fn penguin_flippers() -> (Vec<&'static str>, [Vec<f64>; 3]) {
    let names = ["Adelie", "Chinstrap", "Gentoo"];
    let mut groups = [Vec::new(), Vec::new(), Vec::new()];
    for line in include_str!("data/penguins.csv").lines().skip(1) {
        let mut parts = line.split(',');
        let species = parts.next().unwrap_or_default();
        let flipper: Option<f64> = parts.nth(2).and_then(|v| v.parse().ok());
        if let (Some(index), Some(flipper)) = (names.iter().position(|n| *n == species), flipper) {
            groups[index].push(flipper);
        }
    }
    (names.to_vec(), groups)
}

use malevich::Frame;
include!("support/svg_card.rs");

fn main() {
    let (categories, groups) = penguin_flippers();
    let refs: Vec<&[f64]> = groups.iter().map(Vec::as_slice).collect();
    let chart = malevich::box_plot(categories, refs)
        .title("flipper length by species")
        .y_label("mm");
    let frame = Frame::portable(60, 16);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

fn penguin_flippers() -> (Vec<&'static str>, [Vec<f64>; 3]) {
    let names = ["Adelie", "Chinstrap", "Gentoo"];
    let mut groups = [Vec::new(), Vec::new(), Vec::new()];
    for line in include_str!("data/penguins.csv").lines().skip(1) {
        let mut parts = line.split(',');
        let species = parts.next().unwrap_or_default();
        let flipper: Option<f64> = parts.nth(2).and_then(|v| v.parse().ok());
        if let (Some(index), Some(flipper)) = (names.iter().position(|n| *n == species), flipper) {
            groups[index].push(flipper);
        }
    }
    (names.to_vec(), groups)
}

use malevich::Frame;
include!("support/svg_card.rs");

fn main() {
    let names = ["Adelie", "Chinstrap", "Gentoo"];
    let mut groups = [Vec::new(), Vec::new(), Vec::new()];
    for line in include_str!("data/penguins.csv").lines().skip(1) {
        let mut parts = line.split(',');
        let species = parts.next().unwrap_or_default();
        let flipper: Option<f64> = parts.nth(2).and_then(|v| v.parse().ok());
        if let (Some(index), Some(flipper)) = (names.iter().position(|n| *n == species), flipper) {
            groups[index].push(flipper);
        }
    }
    let refs: Vec<&[f64]> = groups.iter().map(Vec::as_slice).collect();
    let chart = malevich::violin(names, refs)
        .title("flipper length by species, as densities")
        .y_label("mm");
    let frame = Frame::plain(60, 16);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

use malevich::stat::{BoxStats, jitter, kde};
use malevich::{Area, Frame, Plot, Points, Range, Scale};
include!("support/svg_card.rs");

fn main() {
    let names = ["Adelie", "Chinstrap", "Gentoo"];
    let mut groups = [Vec::new(), Vec::new(), Vec::new()];
    for line in include_str!("data/penguins.csv").lines().skip(1) {
        let mut parts = line.split(',');
        let species = parts.next().unwrap_or_default();
        let flipper: Option<f64> = parts.nth(2).and_then(|v| v.parse().ok());
        if let (Some(index), Some(flipper)) = (names.iter().position(|n| *n == species), flipper) {
            groups[index].push(flipper);
        }
    }

    let mut plot = Plot::new()
        .x_scale(Scale::bands(names))
        .title("flipper length by species: cloud, box, and rain")
        .y_label("mm");
    let mut box_low = Vec::new();
    let mut box_high = Vec::new();
    let mut box_q1 = Vec::new();
    let mut box_q3 = Vec::new();
    let mut box_median = Vec::new();
    for (index, group) in groups.iter().enumerate() {
        let center = index as f64;
        // The cloud: a half violin, scaled so every species peaks the same.
        let (positions, density) = kde(group, 128).expect("finite sample");
        let peak = density.iter().copied().fold(f64::MIN_POSITIVE, f64::max);
        let inner = vec![center + 0.05; positions.len()];
        let outer: Vec<f64> = density
            .iter()
            .map(|d| center + 0.05 + d / peak * 0.35)
            .collect();
        plot = plot.layer(Area::horizontal(positions, inner, outer));
        // The rain: every measurement, jittered in a strip left of center.
        let strip = jitter(&vec![center - 0.28; group.len()], 0.2);
        plot = plot.layer(Points::xy(strip, group.clone()));
        // The box, between the two.
        let stats = BoxStats::of(group).expect("finite sample");
        box_low.push(stats.whisker_low);
        box_high.push(stats.whisker_high);
        box_q1.push(stats.q1);
        box_q3.push(stats.q3);
        box_median.push(stats.median);
    }
    let box_x: Vec<f64> = (0..names.len()).map(|i| i as f64 - 0.08).collect();
    plot = plot.layer(
        Range::xy(box_x, box_low, box_high)
            .body(box_q1, box_q3)
            .marker(box_median),
    );
    let frame = Frame::plain(66, 22);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::mark::Dash;
use malevich::stat::{KdeOptions, kde, kde_with};
use malevich::{Frame, Line, Plot, Rule};
include!("support/svg_card.rs");

fn main() {
    // An exponential pile against zero (mean 6 ms), deterministic.
    let latencies: Vec<f64> = (0..600)
        .map(|i| {
            let u = ((i * 7919) % 600) as f64 / 600.0 + 0.0008;
            -u.ln() * 6.0
        })
        .collect();

    let (xs, leaky) = kde(&latencies, 240).expect("finite sample");
    let bounded = KdeOptions::new().bounds(Some(0.0), None);
    let (bxs, honest) = kde_with(&latencies, 240, bounded)
        .expect("valid options")
        .expect("finite sample");

    let plot = Plot::new()
        .layer(Rule::v(0.0).dash(Dash::Dotted))
        .layer(Line::xy(xs, leaky).dash(Dash::Dashed).label("unbounded"))
        .layer(Line::xy(bxs, honest).label("bounded at 0"))
        .title("request latency, density (synthetic)")
        .x_label("ms");
    let frame = Frame::plain(66, 16);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::mark::Dash;
use malevich::stat::Normalization;
use malevich::{Frame, HistogramOptions, Rule, hist_with};
include!("support/svg_card.rs");

fn main() {
    // An exponential pile against zero (mean 6 ms), deterministic.
    let latencies: Vec<f64> = (0..600)
        .map(|i| {
            let u = ((i * 7919) % 600) as f64 / 600.0 + 0.0008;
            -u.ln() * 6.0
        })
        .collect();

    let share = HistogramOptions::new(24)
        .normalization(Normalization::Percent)
        .cumulative(true);
    let plot = hist_with(&latencies[..], share)
        .expect("valid options")
        .layer(Rule::h(95.0).dash(Dash::Dotted).label("p95"))
        .title("requests served within a latency (synthetic)")
        .x_label("ms");
    let frame = Frame::plain(66, 14);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::stat::kde;
use malevich::{Frame, Line, LineStyle, Plot};
include!("support/svg_card.rs");

fn main() {
    let mut state = 7u64;
    let mut uniform = || {
        state = state
            .wrapping_mul(6364136223846793005)
            .wrapping_add(1442695040888963407);
        (state >> 33) as f64 / (1u64 << 31) as f64
    };

    // Eight epochs of "gradients": rough gaussians whose spread collapses and
    // whose center drifts to zero as training settles.
    let epochs: Vec<Vec<f64>> = (0..8)
        .map(|epoch| {
            let progress = epoch as f64 / 7.0;
            let sigma = 1.1 - 0.85 * progress;
            let center = 0.8 * (1.0 - progress);
            (0..600)
                .map(|_| {
                    let rough = uniform() + uniform() + uniform() - 1.5;
                    center + sigma * rough
                })
                .collect()
        })
        .collect();

    // Painter's algorithm: the oldest epoch is the farthest row, drawn first
    // at the highest lift; each nearer row overwrites what it crosses.
    let mut plot = Plot::new().title("gradient distribution by epoch");
    for (epoch, gradients) in epochs.iter().enumerate().rev() {
        let lift = (7 - epoch) as f64 * 0.55;
        let (xs, density) = kde(gradients, 200).expect("finite sample");
        let lifted: Vec<f64> = density.iter().map(|d| lift + d * 1.6).collect();
        plot = plot.layer(Line::xy(xs, lifted).style(LineStyle::Corners));
    }
    let frame = Frame::plain(64, 24);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render(&frame));
}

use malevich::stat::quantiles;
use malevich::{Dash, Frame, Line, Plot, Points};
include!("support/svg_card.rs");

fn main() {
    let noise = |i: usize, seed: f64| {
        let hash = (i as f64 * 12.9898 + seed * 78.233).sin() * 43758.5453;
        (hash - hash.floor()) * 2.0 - 1.0
    };
    // Two samples: near-normal (sum of uniforms) vs the same with a heavy
    // right tail.
    let normalish: Vec<f64> = (0..400)
        .map(|i| (0..6).map(|k| noise(i * 6 + k, 1.0)).sum::<f64>())
        .collect();
    let heavy: Vec<f64> = (0..400)
        .map(|i| {
            let base = (0..6).map(|k| noise(i * 6 + k, 9.0)).sum::<f64>();
            if noise(i, 17.0) > 0.6 {
                base * 2.5
            } else {
                base
            }
        })
        .collect();

    let positions: Vec<f64> = (1..100).map(|p| p as f64 / 100.0).collect();
    let qx = quantiles(&normalish, &positions);
    let qy = quantiles(&heavy, &positions);

    let span = (-4.0, 6.0);
    let plot = Plot::new()
        .layer(
            Line::xy(vec![span.0, span.1], vec![span.0, span.1])
                .label("identity")
                .dash(Dash::Dotted),
        )
        .layer(Points::xy(qx, qy).label("quantiles"))
        .title("Q\u{2013}Q: heavy-tailed vs normal-ish")
        .x_label("normal-ish quantiles")
        .y_label("heavy-tailed");
    let frame = Frame::plain(64, 20);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Frame, Grid};
include!("support/svg_card.rs");

fn main() {
    let requests = [12.0, 12.0, 19.0, 14.0, 23.0, 23.0, 31.0, 26.0, 18.0, 18.0];
    let samples: Vec<f64> = (0..300)
        .map(|i| {
            let i = i as f64;
            ((i * 0.731).sin() + (i * 1.13).sin()) * 2.5 + 6.0
        })
        .collect();
    let stairs = malevich::stairs(&requests[..]).title("requests per window");
    let ecdf = malevich::ecdf(&samples[..]).title("latency ecdf");
    let frame = Frame::plain(76, 13);
    if svg_grid(&[&stairs, &ecdf], 2, &frame) {
        return;
    }
    let grid = Grid::new(2).with(stairs).with(ecdf);
    println!("{}", grid.render(&frame));
}

use malevich::{Frame, Line, Plot};
include!("support/svg_card.rs");

fn main() {
    let plot = Plot::new()
        .layer(Line::function(1.0..100_000.0, |x| 0.5 * x.powf(1.5)).label("0.5 x^1.5"))
        .layer(Line::function(1.0..100_000.0, |x| 20.0 * x.sqrt()).label("20 sqrt x"))
        .title("power laws on log-log axes")
        .log_x()
        .log_y();
    let frame = Frame::plain(64, 16);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Frame, Plot, Points};
include!("support/svg_card.rs");

fn main() {
    let mut length = Vec::new();
    let mut depth = Vec::new();
    let mut species = Vec::new();
    for line in include_str!("data/penguins.csv").lines().skip(1) {
        let mut parts = line.split(',');
        let name = parts.next().unwrap_or_default();
        let bill: f64 = parts
            .next()
            .and_then(|v| v.parse().ok())
            .unwrap_or(f64::NAN);
        let bill_depth: f64 = parts
            .next()
            .and_then(|v| v.parse().ok())
            .unwrap_or(f64::NAN);
        length.push(bill);
        depth.push(bill_depth);
        species.push(name);
    }
    let plot = Plot::new()
        .layer(Points::xy(&length[..], &depth[..]).color_by(species))
        .title("penguin bills by species")
        .x_label("bill length, mm")
        .y_label("depth");
    let frame = Frame::plain(72, 20);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::stat::Fit;
use malevich::{Frame, TrendOptions};
include!("support/svg_card.rs");

fn main() {
    let noise = |i: usize, seed: f64| {
        let hash = (i as f64 * 12.9898 + seed * 78.233).sin() * 43758.5453;
        (hash - hash.floor()) * 2.0 - 1.0
    };
    let n = 60usize;
    let x: Vec<f64> = (0..n)
        .map(|i| i as f64 * 0.5 + noise(i, 2.0) * 0.2)
        .collect();
    let y: Vec<f64> = x
        .iter()
        .enumerate()
        .map(|(i, &v)| 0.8 * v + 4.0 + noise(i, 9.0) * 3.0)
        .collect();

    let fit = Fit::xy(&x, &y);
    let chart = malevich::trend_with(&x[..], &y[..], TrendOptions::new().band(1.96))
        .expect("a positive band multiplier is valid")
        .title(format!(
            "y = {:.2}x + {:.2}   R² = {:.2}",
            fit.slope().unwrap(),
            fit.intercept().unwrap(),
            fit.r_squared().unwrap()
        ))
        .x_label("dose")
        .y_label("response");
    let frame = Frame::plain(72, 20);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

use malevich::Frame;
include!("support/svg_card.rs");

fn main() {
    let x: Vec<f64> = (1..=8).map(|i| i as f64).collect();
    let y: Vec<f64> = x.iter().map(|v| 3.0 + (v * 0.8).sin() * 2.0).collect();
    let error: Vec<f64> = x
        .iter()
        .map(|v| 0.3 + (v * 1.7).cos().abs() * 0.5)
        .collect();
    let chart = malevich::error_bars(&x[..], &y[..], &error[..])
        .title("measurements with uncertainty (synthetic)");
    let frame = Frame::plain(52, 13);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

use malevich::scale::Palette;
use malevich::{Color, Dash, Frame, Plot, Points, Rule};
include!("support/svg_card.rs");

fn main() {
    // Deterministic synthetic differential expression: most genes near zero
    // effect, a regulated tail on both sides.
    let n = 900usize;
    let noise = |i: usize, seed: f64| {
        let hash = (i as f64 * 12.9898 + seed * 78.233).sin() * 43758.5453;
        (hash - hash.floor()) * 2.0 - 1.0
    };
    let mut fold = Vec::with_capacity(n);
    let mut significance = Vec::with_capacity(n);
    for i in 0..n {
        let spread = if i % 7 == 0 { 2.6 } else { 0.7 };
        let log2fc = noise(i, 1.0) * spread;
        let driven = (log2fc.abs() * 1.6 - 0.4 + noise(i, 7.0) * 1.2).max(0.02);
        fold.push(log2fc);
        significance.push(driven); // already -log10 p
    }
    // Partition so "n.s." appears first: category order is first appearance,
    // and the palette below assigns grey to it.
    let class = |fc: f64, p: f64| {
        if p < 2.0 || fc.abs() < 1.0 {
            "n.s."
        } else if fc > 0.0 {
            "up"
        } else {
            "down"
        }
    };
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut classes = Vec::new();
    for wanted in ["n.s.", "down", "up"] {
        for (&fc, &p) in fold.iter().zip(&significance) {
            if class(fc, p) == wanted {
                x.push(fc);
                y.push(p);
                classes.push(wanted);
            }
        }
    }
    let plot = Plot::new()
        .layer(Points::xy(&x[..], &y[..]).color_by(classes))
        .palette(Palette::new(&[
            Color::BrightBlack,      // n.s. — recedes
            Color::Rgb(0, 114, 178), // down — blue
            Color::Rgb(213, 94, 0),  // up — vermillion
        ]))
        .layer(Rule::v(-1.0).dash(Dash::Dashed))
        .layer(Rule::v(1.0).dash(Dash::Dashed))
        .layer(Rule::h(2.0).dash(Dash::Dashed))
        .title("differential expression (synthetic)")
        .x_label("log2 fold change")
        .y_label("-log10 p");
    let frame = Frame::plain(72, 22);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Color, Dash, Frame, Plot, Points, Rule};
include!("support/svg_card.rs");

fn main() {
    let noise = |i: usize, seed: f64| {
        let hash = (i as f64 * 12.9898 + seed * 78.233).sin() * 43758.5453;
        (hash - hash.floor()) * 2.0 - 1.0
    };
    // 12 chromosomes of shrinking size; a handful of loci carry real signal.
    let sizes = [180, 160, 150, 130, 120, 110, 95, 85, 75, 70, 60, 55];
    let hits = [2usize, 6, 9];
    let (mut even_x, mut even_y) = (Vec::new(), Vec::new());
    let (mut odd_x, mut odd_y) = (Vec::new(), Vec::new());
    let mut position = 0usize;
    for (chromosome, &size) in sizes.iter().enumerate() {
        for i in 0..size {
            let mut p = noise(position + i, 1.0).abs() * 2.8;
            if hits.contains(&chromosome) {
                // A peak near the middle of the chromosome.
                let center = (i as f64 - size as f64 / 2.0).abs() / size as f64;
                let lift = (0.5 - center).max(0.0) * 2.0;
                p += lift * (6.5 + noise(position + i, 5.0) * 1.5) * lift;
            }
            let x = (position + i) as f64;
            if chromosome % 2 == 0 {
                even_x.push(x);
                even_y.push(p);
            } else {
                odd_x.push(x);
                odd_y.push(p);
            }
        }
        position += size;
    }
    let plot = Plot::new()
        .layer(Points::xy(&even_x[..], &even_y[..]).color(Color::Rgb(0, 114, 178)))
        .layer(Points::xy(&odd_x[..], &odd_y[..]).color(Color::Rgb(86, 180, 233)))
        .layer(Rule::h(5.0).label("genome-wide").dash(Dash::Dashed))
        .title("association scan (synthetic)")
        .x_label("genomic position")
        .y_label("-log10 p");
    let frame = Frame::plain(76, 20);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::scale::Palette;
use malevich::{Color, Frame, Plot, Range};
include!("support/svg_card.rs");

fn main() {
    let days = 46usize;
    let noise = |i: usize, seed: f64| {
        let hash = (i as f64 * 12.9898 + seed * 78.233).sin() * 43758.5453;
        (hash - hash.floor()) * 2.0 - 1.0
    };
    let mut price = 100.0f64;
    let (mut t, mut low, mut high, mut open, mut close, mut day) = (
        Vec::new(),
        Vec::new(),
        Vec::new(),
        Vec::new(),
        Vec::new(),
        Vec::new(),
    );
    for i in 0..days {
        let drift = if i == 0 {
            0.8
        } else {
            noise(i, 3.0) * 2.2 + 0.1
        };
        let opened = price;
        let closed = opened + drift;
        let wick = 0.4 + noise(i, 11.0).abs() * 1.4;
        t.push(i as f64);
        open.push(opened);
        close.push(closed);
        low.push(opened.min(closed) - wick);
        high.push(opened.max(closed) + wick);
        day.push(if closed >= opened { "up" } else { "down" });
        price = closed;
    }
    let plot = Plot::new()
        .layer(
            Range::xy(&t[..], &low[..], &high[..])
                .body(&open[..], &close[..])
                .color_by(day),
        )
        .palette(Palette::new(&[
            Color::Rgb(0, 158, 115), // up — bluish green
            Color::Rgb(213, 94, 0),  // down — vermillion
        ]))
        .title("daily candles (synthetic)")
        .y_label("price");
    let frame = Frame::plain(72, 20);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Frame, Line, Plot};
include!("support/svg_card.rs");

fn main() {
    let (stamps, ppm): (Vec<f64>, Vec<f64>) = include_str!("data/co2_monthly.csv")
        .lines()
        .skip(1)
        .filter_map(|line| {
            let mut parts = line.split(',');
            let year: i64 = parts.next()?.parse().ok()?;
            let month: u64 = parts.next()?.parse().ok()?;
            let ppm: f64 = parts.next()?.parse().ok()?;
            Some((month_stamp(year, month), ppm))
        })
        .unzip();
    let chart = Plot::new()
        .layer(Line::xy(&stamps[..], &ppm[..]))
        .title("atmospheric CO2 at Mauna Loa (NOAA)")
        .y_label("ppm")
        .time_x();
    let frame = Frame::plain(76, 18);
    if svg_card(&chart, &frame) {
        return;
    }
    println!("{}", chart.render_best(&frame));
}

/// The first of the month as unix seconds (Hinnant's civil-date arithmetic).
fn month_stamp(year: i64, month: u64) -> f64 {
    let y = year - i64::from(month <= 2);
    let era = if y >= 0 { y } else { y - 399 } / 400;
    let yoe = (y - era * 400) as u64;
    let doy = (153 * (if month > 2 { month - 3 } else { month + 9 }) + 2) / 5;
    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
    ((era * 146_097 + doe as i64 - 719_468) * 86_400) as f64
}

use malevich::stat::{TimeUnit, calendar_bins};
use malevich::{Bars, Frame, Plot, Scale};
include!("support/svg_card.rs");

fn main() {
    // Commits over fourteen months, bursty, with a silent August.
    let start = 1_735_689_600.0; // 2025-01-01 00:00 UTC
    let stamps: Vec<f64> = (0..900)
        .map(|i| {
            let day = ((i * 7919) % 425) as f64;
            let hour = ((i * 104_729) % 24) as f64;
            start + day * 86_400.0 + hour * 3_600.0
        })
        .filter(|t| !(*t >= start + 212.0 * 86_400.0 && *t < start + 243.0 * 86_400.0))
        .collect();

    let bins = calendar_bins(&stamps, TimeUnit::Month).expect("finite timestamps");
    let counts: Vec<f64> = bins.counts().iter().map(|&count| count as f64).collect();
    let plot = Plot::new()
        .layer(Bars::intervals(bins.starts(), bins.ends(), counts))
        .y_scale(Scale::Integer)
        .time_x()
        .title("commits per month (synthetic)");
    let frame = Frame::plain(72, 14);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Frame, Line, Plot, Rule};
include!("support/svg_card.rs");

fn main() {
    let open = 1_785_749_400.0; // 2026-08-03 09:30 UTC
    let stamps: Vec<f64> = (0..=390).map(|m| open + f64::from(m) * 60.0).collect();
    let mut price = 184.20;
    let prices: Vec<f64> = (0..=390)
        .map(|m| {
            let tick = ((m * 7919) % 97) as f64 / 97.0 - 0.5;
            price += tick * 0.35 + (f64::from(m) / 390.0 - 0.4) * 0.02;
            price
        })
        .collect();

    let plot = Plot::new()
        .layer(Rule::h(prices[0]).label("open"))
        .layer(Line::xy(&stamps[..], &prices[..]).label("last"))
        .time_x()
        .title("one session (synthetic)")
        .x_label("time (UTC)")
        .y_label("$");
    let frame = Frame::plain(72, 16);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Dash, Frame, Line, Plot, Rule};
include!("support/svg_card.rs");

fn main() {
    let (steps, losses): (Vec<f64>, Vec<f64>) = include_str!("data/topos_loss.csv")
        .lines()
        .filter_map(|line| {
            let (step, loss) = line.split_once(',')?;
            let step: f64 = step.parse().ok()?;
            let loss: f64 = loss.parse().ok()?;
            Some((step, loss))
        })
        .unzip();
    let smoothed = malevich::stat::Window::new(25).mean(&losses);

    let plot = Plot::new()
        .layer(Line::xy(&steps[..], &losses[..]).label("minibatch"))
        .layer(
            Line::xy(&steps[..], &smoothed[..])
                .label("rolling mean")
                .glow(),
        )
        .layer(Rule::h(2.45).label("bigram limit").dash(Dash::Dashed))
        .title("topos: bigram training on 32k names")
        .x_label("step")
        .y_label("loss");
    let frame = Frame::plain(76, 19);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::stat::{Bins, Reducer, binned, ewma};
use malevich::{Area, Frame, Line, LineStyle, Plot};
include!("support/svg_card.rs");

fn main() {
    let steps_per_run = 400usize;
    let mut state = 3u64;
    let mut uniform = || {
        state = state
            .wrapping_mul(6364136223846793005)
            .wrapping_add(1442695040888963407);
        (state >> 33) as f64 / (1u64 << 31) as f64
    };

    // Five seeds: shared decay, per-seed floor and noise.
    let (mut steps, mut losses) = (Vec::new(), Vec::new());
    for seed in 0..5 {
        let floor = 0.30 + 0.05 * seed as f64;
        for step in 0..steps_per_run {
            let decay = 2.4 * (-(step as f64) / 90.0).exp();
            let noise = 1.0 + 0.55 * (uniform() - 0.5);
            steps.push(step as f64);
            losses.push((floor + decay) * noise);
        }
    }

    let bins = Bins::new(0.0, 8.0, 50);
    let p10 = binned(&steps, &losses, &bins, Reducer::Percentile(0.1));
    let p50 = binned(&steps, &losses, &bins, Reducer::Median);
    let p90 = binned(&steps, &losses, &bins, Reducer::Percentile(0.9));
    let smooth = ewma(&p50, 0.8);
    let centers: Vec<f64> = (0..50).map(|bin| 4.0 + 8.0 * bin as f64).collect();

    let plot = Plot::new()
        .layer(
            Area::between(&centers[..], &p10[..], &p90[..])
                .label("p10-p90")
                .opacity(0.35),
        )
        .layer(Line::xy(&centers[..], &p50[..]).label("median"))
        // Corners glyphs keep the smoothed curve visible over the band fill
        // in cell output; subpixel lines would drown in it.
        .layer(
            Line::xy(&centers[..], &smooth[..])
                .style(LineStyle::Corners)
                .label("ewma"),
        )
        .log_y()
        .x_label("step")
        .title("loss across 5 seeds");
    let frame = Frame::plain(64, 22);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render(&frame));
}

use malevich::{Area, Frame, Plot};
include!("support/svg_card.rs");

fn main() {
    let x: Vec<f64> = (0..80).map(f64::from).collect();
    let solar: Vec<f64> = x.iter().map(|v| 3.0 + (v * 0.2).sin() + v * 0.02).collect();
    let wind: Vec<f64> = x
        .iter()
        .map(|v| 2.0 + (v * 0.13).cos().abs() * 1.5)
        .collect();
    let hydro: Vec<f64> = x.iter().map(|v| 1.0 + (v * 0.07).sin().abs()).collect();

    let bands = malevich::stat::stack(&[&solar, &wind, &hydro]);
    let mut plot = Plot::new().title("energy mix, stacked (synthetic)");
    for ((low, high), label) in bands.iter().zip(["solar", "wind", "hydro"]) {
        plot = plot.layer(Area::between(&x[..], &low[..], &high[..]).label(label));
    }
    let frame = Frame::plain(64, 16);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::mark::Dash;
use malevich::stat::{Reducer, Window, WindowAnchor};
use malevich::{Color, Frame, Line, Plot};
include!("support/svg_card.rs");

fn main() {
    // A random-walk price, deterministic.
    let mut price = 100.0f64;
    let mut state = 0x2545_F491_4F6C_DD1Du64;
    let prices: Vec<f64> = (0..160)
        .map(|_| {
            state ^= state << 13;
            state ^= state >> 7;
            state ^= state << 17;
            let step = ((state >> 11) as f64 / (1u64 << 53) as f64 - 0.5) * 3.0;
            price = (price + step).max(1.0);
            price
        })
        .collect();
    let x: Vec<f64> = (0..prices.len()).map(|i| i as f64).collect();

    let window = Window::new(20).anchor(WindowAnchor::Middle);
    let mean = window.mean(&prices);
    let deviation = window.reduce(&prices, Reducer::Deviation);
    let lower: Vec<f64> = mean
        .iter()
        .zip(&deviation)
        .map(|(m, s)| m - 2.0 * s)
        .collect();
    let upper: Vec<f64> = mean
        .iter()
        .zip(&deviation)
        .map(|(m, s)| m + 2.0 * s)
        .collect();

    let plot = Plot::new()
        .layer(Line::xy(&x[..], &upper[..]).label("±2σ"))
        .layer(Line::xy(&x[..], &lower[..]).color(Color::Default))
        .layer(
            Line::xy(&x[..], &mean[..])
                .dash(Dash::Dashed)
                .label("20-day mean"),
        )
        .layer(Line::xy(&x[..], &prices[..]).label("price"))
        .title("Bollinger bands: a centered window's mean ± 2σ (synthetic)")
        .x_label("day");
    let frame = Frame::plain(72, 20);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render_best(&frame));
}

use malevich::{Dash, Frame, Line, Plot, stat};
include!("support/svg_card.rs");

fn main() {
    // A deterministic classifier in miniature: positive scores center higher
    // than negatives with real overlap (an LCG stands in for a model).
    let mut state = 5u64;
    let mut uniform = || {
        state = state
            .wrapping_mul(6364136223846793005)
            .wrapping_add(1442695040888963407);
        (state >> 33) as f64 / (1u64 << 31) as f64
    };
    let (mut scores, mut labels) = (Vec::new(), Vec::new());
    for _ in 0..300 {
        // Rough gaussians from averaged uniforms; separation ~1 sigma.
        let noise = uniform() + uniform() + uniform() - 1.5;
        let positive = uniform() < 0.5;
        scores.push(if positive { 0.55 + noise } else { noise });
        labels.push(positive);
    }

    let (fpr, tpr) = stat::roc(&scores, &labels);
    let area = stat::auc(&fpr, &tpr);
    let plot = Plot::new()
        .layer(
            Line::xy(&[0.0, 1.0][..], &[0.0, 1.0][..])
                .label("chance")
                .dash(Dash::Dotted),
        )
        .layer(Line::xy(&fpr[..], &tpr[..]).label("model"))
        .x_label("false positive rate")
        .y_label("true positive rate")
        .title(format!("ROC, AUC {area:.3}"));
    let frame = Frame::plain(58, 22);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render(&frame));
}

use malevich::stat::{Bins, Reducer, binned};
use malevich::{Dash, Frame, Line, Plot, PointStyle, Points};
include!("support/svg_card.rs");

fn main() {
    // A deterministic overconfident classifier: predictions cluster near the
    // extremes, but the true hit rate is closer to the middle than claimed.
    let mut state = 11u64;
    let mut uniform = || {
        state = state
            .wrapping_mul(6364136223846793005)
            .wrapping_add(1442695040888963407);
        (state >> 33) as f64 / (1u64 << 31) as f64
    };
    let (mut confidence, mut correct) = (Vec::new(), Vec::new());
    for _ in 0..4000 {
        let claimed = uniform();
        // The real accuracy pulls the claim 40% of the way back to a coin flip.
        let actual = 0.5 + (claimed - 0.5) * 0.6;
        confidence.push(claimed);
        correct.push(if uniform() < actual { 1.0 } else { 0.0 });
    }

    let bins = Bins::new(0.0, 0.1, 10);
    let accuracy = binned(&confidence, &correct, &bins, Reducer::Mean);
    let centers: Vec<f64> = (0..10).map(|bin| 0.05 + 0.1 * bin as f64).collect();

    let plot = Plot::new()
        .layer(
            Line::xy(&[0.0, 1.0][..], &[0.0, 1.0][..])
                .label("perfect")
                .dash(Dash::Dotted),
        )
        .layer(Line::xy(&centers[..], &accuracy[..]).label("model"))
        .layer(Points::xy(&centers[..], &accuracy[..]).style(PointStyle::Circle))
        .x_label("claimed confidence")
        .y_label("observed accuracy")
        .title("reliability");
    let frame = Frame::plain(58, 22);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render(&frame));
}

use malevich::scale::Colormap;
use malevich::{Align, Cells, Frame, Plot, Scale, Text};
include!("support/svg_card.rs");

fn main() {
    let classes = ["cat", "dog", "bird"];
    let counts = [
        38.0, 2.0, 0.0, //
        3.0, 33.0, 4.0, //
        1.0, 5.0, 34.0, //
    ];
    let mut plot = Plot::new()
        .layer(Cells::matrix(classes.len(), &counts[..]).colormap(Colormap::GREYS))
        .x_scale(Scale::bands(classes))
        .y_scale(Scale::bands(classes))
        .x_label("predicted")
        .y_label("true")
        .title("validation confusion");
    for (index, &count) in counts.iter().enumerate() {
        let (column, row) = (index % classes.len(), index / classes.len());
        plot = plot
            .layer(Text::at(column as f64, row as f64, format!("{count:.0}")).align(Align::Center));
    }
    let frame = Frame::plain(46, 16);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render(&frame));
}

use malevich::scale::Colormap;
use malevich::{Cells, Frame, Plot, Scale};
include!("support/svg_card.rs");

fn main() {
    let tokens = ["The", "robot", "ate", "the", "red", "apple", "."];
    let n = tokens.len();
    // A causal head in miniature: each query attends to itself and its recent
    // past with geometrically decaying weight, plus one long-range association
    // — the period looks back at the subject. Rows are normalized like a
    // softmax; the masked future stays exactly zero.
    let mut weights = vec![0.0f64; n * n];
    for query in 0..n {
        for key in 0..=query {
            weights[query * n + key] = (-1.9 * (query - key) as f64).exp();
        }
    }
    weights[6 * n + 1] = 0.35;
    for query in 0..n {
        let row = &mut weights[query * n..(query + 1) * n];
        let sum: f64 = row.iter().sum();
        for weight in row {
            *weight /= sum;
        }
    }

    let plot = Plot::new()
        .layer(Cells::matrix(n, &weights[..]).colormap(Colormap::MAGMA.log()))
        .x_scale(Scale::bands(tokens))
        .y_scale(Scale::bands(tokens))
        .x_label("key")
        .y_label("query")
        .colorbar()
        .title("attention, layer 7 head 3");
    let frame = Frame::plain(66, 20);
    if svg_card(&plot, &frame) {
        return;
    }
    println!("{}", plot.render(&frame));
}