The eight marks

use malevich::{Dash, Line, LineStyle, Plot};
let x: Vec<f64> = (0..40).map(|i| f64::from(i) * 0.25).collect();
let wave: Vec<f64> = x.iter().map(|x| (x * 1.1).sin() * 4.0 + 5.0).collect();
let lower: Vec<f64> = wave.iter().map(|y| y - 4.5).collect();
Plot::new()
    .layer(Line::xy(x.clone(), wave).label("Pixels, the default"))
    .layer(Line::xy(x.clone(), lower.clone()).style(LineStyle::Corners).label("Corners, one glyph per column"))
    .layer(Line::xy(x, lower.iter().map(|y| y - 4.5).collect::<Vec<_>>()).dash(Dash::Dashed).label("dashed"))
    .title("line styles")

use malevich::{Line, Plot};
// A function samples itself once per subpixel column: no resolution to choose.
Plot::new()
    .layer(Line::function(0.0..12.6, f64::sin).label("sin x"))
    .layer(Line::function(0.0..12.6, |x| (x * 0.5).cos() * 0.6).label("0.6 cos x/2"))
    .title("Line::function")

use malevich::scale::Colormap;
use malevich::{Line, Plot};
// `grade` colors the line by a third series through a colormap: here the
// temperature of a run colors its altitude profile.
let km: Vec<f64> = (0..120).map(|i| f64::from(i) * 0.1).collect();
let altitude: Vec<f64> = km.iter().map(|k| 300.0 + 180.0 * (k * 0.6).sin() + 40.0 * (k * 2.3).cos()).collect();
let temperature: Vec<f64> = km.iter().map(|k| 12.0 + 9.0 * (k * 0.35).sin()).collect();
Plot::new()
    .layer(Line::xy(km, altitude).grade(temperature, Colormap::MAGMA).glow())
    .colorbar()
    .title("altitude, colored by temperature")
    .x_label("km")
    .y_label("m")

use malevich::{Plot, PointStyle, Points};
let styles = [
    (PointStyle::Dot, "Dot"), (PointStyle::Plus, "Plus"), (PointStyle::Cross, "Cross"),
    (PointStyle::Asterisk, "Asterisk"), (PointStyle::Circle, "Circle"),
];
let mut plot = Plot::new();
for (row, (style, name)) in styles.into_iter().enumerate() {
    let x: Vec<f64> = (0..8).map(|i| f64::from(i) * 1.5 + row as f64 * 0.3).collect();
    let y: Vec<f64> = x.iter().map(|x| row as f64 * 2.0 + (x * 0.8).sin() * 0.6).collect();
    plot = plot.layer(Points::xy(x, y).style(style).label(name));
}
plot.title("point styles")

use malevich::{Plot, Points};
use super::penguins;
let p = penguins();
Plot::new()
    .layer(Points::xy(p.flipper, p.mass).color_by(p.species))
    .title("flipper length against body mass")
    .x_label("mm")
    .y_label("g")

use malevich::{Bars, Plot};
Plot::new()
    .layer(Bars::new(["rust", "go", "python", "typescript", "zig"], vec![68.0, 41.0, 55.0, 62.0, 12.0]))
    .title("Bars::new — one bar per band")

use malevich::{Bars, Plot};
// Contiguous spans on a numeric axis: bin 0 starts at 10 and each is 5 wide.
Plot::new()
    .layer(Bars::spans(10.0, 5.0, vec![2.0, 9.0, 17.0, 12.0, 6.0, 3.0, 1.0]))
    .title("Bars::spans — contiguous bins from 10, width 5")

use malevich::{Bars, Plot};
// Irregular bins: each bar between its own edges. Widths of 1, 2, 4, 8, 16.
let starts = vec![1.0, 2.0, 4.0, 8.0, 16.0];
let ends = vec![2.0, 4.0, 8.0, 16.0, 32.0];
Plot::new()
    .layer(Bars::intervals(starts, ends, vec![14.0, 22.0, 31.0, 18.0, 6.0]))
    .title("Bars::intervals — bins of unequal width")

use malevich::{Bars, Plot};
// A per-bar base is the y2 channel: the second layer starts where the first ends.
let quarters = ["Q1", "Q2", "Q3", "Q4"];
let hardware = vec![12.0, 15.0, 11.0, 19.0];
let software = [8.0, 9.5, 14.0, 12.0];
Plot::new()
    .layer(Bars::new(quarters, hardware.clone()).label("hardware"))
    .layer(Bars::new(quarters, software.iter().zip(&hardware).map(|(s, h)| s + h).collect::<Vec<_>>()).base(hardware).label("software"))
    .title("stacked through Bars::base")

use malevich::{Bars, Plot, Rule, Scale};
// Long category names take the measured label gutter instead of a band's width.
let workloads = ["slice a buffer", "iterate indices", "walk an adjacency list", "memo lookup", "random access"];
Plot::new()
    .y_scale(Scale::bands(workloads))
    .layer(Bars::new(workloads, vec![1.02, 1.38, 2.11, 0.91, 1.63]).horizontal())
    .layer(Rule::v(1.0).label("baseline"))
    .title("Bars::horizontal")
    .x_label("speedup, ×")

use malevich::{Area, Line, Plot};
let x: Vec<f64> = (0..60).map(f64::from).collect();
let mid: Vec<f64> = x.iter().map(|x| 10.0 + 4.0 * (x * 0.15).sin()).collect();
let low: Vec<f64> = mid.iter().zip(&x).map(|(m, x)| m - 1.0 - x * 0.03).collect();
let high: Vec<f64> = mid.iter().zip(&x).map(|(m, x)| m + 1.0 + x * 0.03).collect();
let floor: Vec<f64> = x.iter().map(|x| 2.0 + (x * 0.3).cos()).collect();
Plot::new()
    .layer(Area::xy(x.clone(), floor).label("Area::xy, from the baseline"))
    .layer(Area::between(x.clone(), low, high).opacity(0.35).label("Area::between, a band"))
    .layer(Line::xy(x, mid).label("the line inside it"))
    .title("areas")

use malevich::stat::kde;
use malevich::{Area, Plot};
use super::penguins;
// A horizontal area is a fill along y: the two halves of a violin are one each.
let flippers = penguins().of("Gentoo", &penguins().flipper);
let (ys, density) = kde(&flippers, 120).expect("enough data");
let left: Vec<f64> = density.iter().map(|d| -d).collect();
Plot::new()
    .layer(Area::horizontal(ys.clone(), vec![0.0; ys.len()], density).label("Area::horizontal"))
    .layer(Area::horizontal(ys.clone(), left, vec![0.0; ys.len()]))
    .title("a violin is two horizontal areas")
    .y_label("flipper, mm")

use malevich::{Cells, Plot, Scale};
// A value grid: row-major, rows labeled in matrix order on a band axis.
let months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"];
let hours = ["00", "04", "08", "12", "16", "20"];
let mut values = Vec::new();
for row in 0..6 {
    for column in 0..6 {
        values.push(20.0 + 18.0 * ((row as f64 - 2.5) * 0.7).cos() * ((column as f64 - 3.0) * 0.5).cos());
    }
}
Plot::new()
    .layer(Cells::matrix(6, values))
    .x_scale(Scale::bands(hours))
    .y_scale(Scale::bands(months))
    .colorbar()
    .title("Cells::matrix — a value grid under a colormap")

use malevich::{Cells, Plot};
// Direct colors, no colormap: an image is one more cell grid.
let (w, h) = (48, 20);
let mut pixels = Vec::with_capacity(w * h);
for row in 0..h {
    for column in 0..w {
        let (x, y) = (column as f64 / w as f64, row as f64 / h as f64);
        let r = (255.0 * (0.5 + 0.5 * (x * 6.3).sin())) as u8;
        let g = (255.0 * (0.5 + 0.5 * (y * 6.3 + 1.0).sin())) as u8;
        let b = (255.0 * (0.5 + 0.5 * ((x + y) * 4.0).cos())) as u8;
        pixels.push((r, g, b));
    }
}
Plot::new().layer(Cells::rgb(w, pixels)).axes(false).title("Cells::rgb")

use malevich::{Cells, Plot, Points};
// Categorical regions: each cell names a class; the legend follows the palette.
let n = 40;
let mut labels = Vec::with_capacity(n * n);
for row in 0..n {
    for column in 0..n {
        let (x, y) = (column as f64 / n as f64 * 4.0 - 2.0, 2.0 - row as f64 / n as f64 * 4.0);
        labels.push(if (x * x + y * y).sqrt() < 1.0 { "inside" } else if x + y > 1.4 { "north-east" } else { "outside" });
    }
}
let ring: Vec<f64> = (0..24).map(|i| f64::from(i) * 0.26).collect();
Plot::new()
    .layer(Cells::classes(n, labels).extents((-2.0, 2.0), (-2.0, 2.0)))
    .layer(Points::xy(ring.iter().map(|t| t.cos() * 1.05).collect::<Vec<_>>(), ring.iter().map(|t| t.sin() * 1.05).collect::<Vec<_>>()).label("boundary points"))
    .title("Cells::classes — a decision region")

use malevich::scale::Colormap;
use malevich::stat::Reducer;
use malevich::{Cells, Plot};
// A 600×300 grid onto a few dozen cells: every screen bucket owns the cells
// whose centers fall inside it and shows their maximum, so the sparse
// spikes survive. Extents place the grid in data coordinates.
let (w, h) = (600, 300);
let mut unit = super::noise(11);
let mut field = Vec::with_capacity(w * h);
for row in 0..h {
    for column in 0..w {
        let (x, y) = (column as f64 / 100.0, row as f64 / 100.0);
        let base = ((x * 2.0).sin() * (y * 3.0).cos()).abs() * 0.3;
        field.push(if unit() < 0.0008 { 1.0 } else { base });
    }
}
Plot::new()
    .layer(Cells::matrix(w, field).extents((0.0, 6.0), (0.0, 3.0)).reduce(Reducer::Max).colormap(Colormap::CIVIDIS))
    .colorbar()
    .title("180,000 cells, max-reduced")
    .x_label("s")
    .y_label("kHz")

use malevich::{Plot, Points, Range};
// An interval per measurement: error bars are a Range around each point.
let dose = vec![1.0, 2.0, 4.0, 8.0, 16.0, 32.0];
let response = vec![0.12, 0.21, 0.38, 0.55, 0.71, 0.77];
let error = vec![0.04, 0.05, 0.06, 0.05, 0.07, 0.09];
let low: Vec<f64> = response.iter().zip(&error).map(|(r, e)| r - e).collect();
let high: Vec<f64> = response.iter().zip(&error).map(|(r, e)| r + e).collect();
Plot::new()
    .layer(Range::xy(dose.clone(), low, high))
    .layer(Points::xy(dose, response))
    .log_x()
    .title("Range::xy — an interval at each x")
    .x_label("dose")
    .y_label("response")

use malevich::stat::BoxStats;
use malevich::{Plot, Range};
use super::penguins;
// The box plot, spelled out: whiskers, a body from q1 to q3, a marker at the median.
let p = penguins();
let species = ["Adelie", "Chinstrap", "Gentoo"];
let stats: Vec<BoxStats> = species.iter().map(|s| BoxStats::of(&p.of(s, &p.flipper)).expect("data")).collect();
Plot::new()
    .layer(
        Range::over(species, stats.iter().map(|s| s.whisker_low).collect::<Vec<_>>(), stats.iter().map(|s| s.whisker_high).collect::<Vec<_>>())
            .body(stats.iter().map(|s| s.q1).collect::<Vec<_>>(), stats.iter().map(|s| s.q3).collect::<Vec<_>>())
            .marker(stats.iter().map(|s| s.median).collect::<Vec<_>>()),
    )
    .title("Range::over with body and marker")
    .y_label("flipper, mm")

use malevich::{Dash, Line, Plot, Rule};
let x: Vec<f64> = (0..100).map(f64::from).collect();
let y: Vec<f64> = x.iter().map(|x| 60.0 + 25.0 * (x * 0.08).sin() + x * 0.2).collect();
Plot::new()
    .layer(Rule::v_span(10.0, 30.0).label("warm-up"))
    .layer(Rule::h_span(70.0, 80.0).label("tolerance"))
    .layer(Line::xy(x, y).label("signal"))
    .layer(Rule::h(60.0).dash(Dash::Dashed).label("baseline"))
    .layer(Rule::v(75.0).dash(Dash::Dotted).label("deploy"))
    .title("rules: lines and spans")

use malevich::{Align, Bars, Plot, Text};
// Text at data coordinates; on a band axis, `align` sets it in the band's
// own box, so labels and annotations land in lockstep.
let cities = ["Oslo", "Lima", "Osaka", "Cairo"];
let values = vec![14.0, 22.0, 9.0, 31.0];
let mut plot = Plot::new().layer(Bars::new(cities, values.clone()));
for (index, value) in values.iter().enumerate() {
    plot = plot.layer(Text::at(index as f64, value + 2.5, format!("{value}")).align(Align::Center));
}
plot.layer(Text::at(1.0, 34.0, "Text::at, aligned to its band")).y_max(38.0).title("annotated bars")