Struct GGPlot 

pub struct GGPlot { /* private fields */ }

The top-level plot specification — builder pattern.

Implementations

impl GGPlot

pub fn new(data: impl GGData) -> Self

Create a new plot with the given data source.

Examples found in repository

examples/bar_chart.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/coord_flip.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

examples/gallery.rs (line 56)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

/// The same plot rendered under every built-in theme.
fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

examples/annotations.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/density.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

examples/scatter.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

Additional examples can be found in:

• examples/loess_smooth.rs
• examples/histogram.rs
• examples/log_scale.rs
• examples/continuous_color.rs
• examples/faceted.rs
• examples/color_palettes.rs
• examples/supplier_leadtime.rs

pub fn aes(self, mapping: Aes) -> Self

Set the plot-level aesthetic mapping.

Examples found in repository

examples/bar_chart.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/coord_flip.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

examples/gallery.rs (line 57)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

/// The same plot rendered under every built-in theme.
fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

examples/annotations.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/density.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

examples/scatter.rs (lines 24-29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

Additional examples can be found in:

• examples/loess_smooth.rs
• examples/histogram.rs
• examples/log_scale.rs
• examples/continuous_color.rs
• examples/faceted.rs
• examples/color_palettes.rs
• examples/supplier_leadtime.rs

pub fn geom_point(self) -> Self

Examples found in repository

examples/gallery.rs (line 58)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

/// The same plot rendered under every built-in theme.
fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

examples/annotations.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/scatter.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

examples/loess_smooth.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate noisy sine wave data
    let x: Vec<f64> = (0..80).map(|i| (i as f64) * 0.1).collect();
    let y: Vec<f64> = (0..80)
        .map(|i| {
            let xv = (i as f64) * 0.1;
            let noise = ((i * 17 + 3) % 11) as f64 / 11.0 - 0.5; // deterministic pseudo-noise
            (xv * 0.8).sin() * 2.0 + noise * 1.5
        })
        .collect();

    let df = df! {
        "x" => &x,
        "y" => &y,
    }?;

    // Linear smooth (default)
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth()
        .title("Linear Smooth (method = lm)")
        .save("smooth_lm.svg")?;

    println!("Saved smooth_lm.svg");

    // LOESS smooth
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth::default().loess(0.3))
        .title("LOESS Smooth (span = 0.3)")
        .save("smooth_loess.svg")?;

    println!("Saved smooth_loess.svg");
    Ok(())
}

examples/log_scale.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Exponential growth data (e.g., population, bacteria count)
    let year: Vec<f64> = (0..30).map(|i| 1990.0 + i as f64).collect();
    let count: Vec<f64> = (0..30)
        .map(|i| {
            let base = 100.0 * (1.15_f64).powi(i); // 15% growth per year
            let noise = ((i * 37 + 7) % 13) as f64 / 13.0 * 0.2 + 0.9;
            base * noise
        })
        .collect();

    let df = df! {
        "year" => &year,
        "count" => &count,
    }?;

    // Linear scale — exponential curve
    GGPlot::new(df.clone())
        .aes(Aes::new().x("year").y("count"))
        .geom_point()
        .geom_line()
        .title("Exponential Growth (Linear Scale)")
        .xlab("Year")
        .ylab("Count")
        .save("log_scale_linear.svg")?;

    println!("Saved log_scale_linear.svg");

    // Log10 y-axis — should appear roughly linear
    GGPlot::new(df)
        .aes(Aes::new().x("year").y("count"))
        .geom_point()
        .geom_line()
        .scale_y_log10()
        .title("Exponential Growth (Log10 Y Scale)")
        .xlab("Year")
        .ylab("Count (log10)")
        .save("log_scale_log10.svg")?;

    println!("Saved log_scale_log10.svg");
    Ok(())
}

examples/continuous_color.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate scatter data with a continuous variable for color
    let x: Vec<f64> = (0..200)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.3)
        })
        .collect();
    let y: Vec<f64> = (0..200)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.3)
        })
        .collect();
    let z: Vec<f64> = (0..200).map(|i| i as f64 * 0.05).collect();

    let df = df! {
        "x" => &x,
        "y" => &y,
        "z" => &z,
    }?;

    // Default blue-to-red gradient
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .title("Continuous Color (default gradient)")
        .xlab("X")
        .ylab("Y")
        .save("continuous_color.svg")?;

    println!("Saved continuous_color.svg");

    // Custom gradient: dark blue to yellow
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_gradient(RGBAColor::new(10, 30, 100), RGBAColor::new(255, 230, 50))
        .title("Continuous Color (custom gradient)")
        .xlab("X")
        .ylab("Y")
        .save("continuous_color_custom.svg")?;

    println!("Saved continuous_color_custom.svg");
    Ok(())
}

Additional examples can be found in:

• examples/faceted.rs
• examples/color_palettes.rs

pub fn geom_point_with(self, geom: GeomPoint) -> Self

pub fn geom_line(self) -> Self

Examples found in repository

examples/gallery.rs (line 381)

fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

examples/annotations.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/log_scale.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Exponential growth data (e.g., population, bacteria count)
    let year: Vec<f64> = (0..30).map(|i| 1990.0 + i as f64).collect();
    let count: Vec<f64> = (0..30)
        .map(|i| {
            let base = 100.0 * (1.15_f64).powi(i); // 15% growth per year
            let noise = ((i * 37 + 7) % 13) as f64 / 13.0 * 0.2 + 0.9;
            base * noise
        })
        .collect();

    let df = df! {
        "year" => &year,
        "count" => &count,
    }?;

    // Linear scale — exponential curve
    GGPlot::new(df.clone())
        .aes(Aes::new().x("year").y("count"))
        .geom_point()
        .geom_line()
        .title("Exponential Growth (Linear Scale)")
        .xlab("Year")
        .ylab("Count")
        .save("log_scale_linear.svg")?;

    println!("Saved log_scale_linear.svg");

    // Log10 y-axis — should appear roughly linear
    GGPlot::new(df)
        .aes(Aes::new().x("year").y("count"))
        .geom_point()
        .geom_line()
        .scale_y_log10()
        .title("Exponential Growth (Log10 Y Scale)")
        .xlab("Year")
        .ylab("Count (log10)")
        .save("log_scale_log10.svg")?;

    println!("Saved log_scale_log10.svg");
    Ok(())
}

pub fn geom_line_with(self, geom: GeomLine) -> Self

pub fn geom_bar(self) -> Self

Examples found in repository

examples/bar_chart.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/gallery.rs (line 138)

fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

pub fn geom_bar_with(self, geom: GeomBar) -> Self

pub fn geom_histogram(self) -> Self

pub fn geom_histogram_with(self, geom: GeomHistogram) -> Self

Examples found in repository

examples/gallery.rs (lines 109-112)

fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

examples/histogram.rs (lines 26-29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate approximate normal distribution using central limit theorem
    let values: Vec<f64> = (0..1000)
        .map(|i: i32| {
            // Sum of pseudo-random uniform values → approx normal by CLT
            let r1 = ((i * 1237 + 5678) % 1000) as f64 / 1000.0;
            let r2 = ((i * 8731 + 4321) % 1000) as f64 / 1000.0;
            let r3 = ((i * 4567 + 8901) % 1000) as f64 / 1000.0;
            let r4 = ((i * 6543 + 2109) % 1000) as f64 / 1000.0;
            let r5 = ((i * 3571 + 7654) % 1000) as f64 / 1000.0;
            let r6 = ((i * 9137 + 3456) % 1000) as f64 / 1000.0;
            // Sum of 6 uniforms: mean=3, std≈0.745; normalize to mean=0, std≈1.5
            (r1 + r2 + r3 + r4 + r5 + r6 - 3.0) * 2.0
        })
        .collect();

    let df = df! {
        "measurement" => values,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 25,
            ..Default::default()
        })
        .title("Distribution of Measurements")
        .xlab("Value")
        .ylab("Frequency")
        .save("histogram.svg")?;

    println!("Saved histogram.svg");
    Ok(())
}

pub fn geom_boxplot(self) -> Self

pub fn geom_boxplot_with(self, geom: GeomBoxplot) -> Self

Examples found in repository

examples/gallery.rs (lines 162-165)

fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

pub fn geom_smooth(self) -> Self

Examples found in repository

examples/loess_smooth.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate noisy sine wave data
    let x: Vec<f64> = (0..80).map(|i| (i as f64) * 0.1).collect();
    let y: Vec<f64> = (0..80)
        .map(|i| {
            let xv = (i as f64) * 0.1;
            let noise = ((i * 17 + 3) % 11) as f64 / 11.0 - 0.5; // deterministic pseudo-noise
            (xv * 0.8).sin() * 2.0 + noise * 1.5
        })
        .collect();

    let df = df! {
        "x" => &x,
        "y" => &y,
    }?;

    // Linear smooth (default)
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth()
        .title("Linear Smooth (method = lm)")
        .save("smooth_lm.svg")?;

    println!("Saved smooth_lm.svg");

    // LOESS smooth
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth::default().loess(0.3))
        .title("LOESS Smooth (span = 0.3)")
        .save("smooth_loess.svg")?;

    println!("Saved smooth_loess.svg");
    Ok(())
}

pub fn geom_smooth_with(self, geom: GeomSmooth) -> Self

Examples found in repository

examples/gallery.rs (lines 83-86)

fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

examples/loess_smooth.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate noisy sine wave data
    let x: Vec<f64> = (0..80).map(|i| (i as f64) * 0.1).collect();
    let y: Vec<f64> = (0..80)
        .map(|i| {
            let xv = (i as f64) * 0.1;
            let noise = ((i * 17 + 3) % 11) as f64 / 11.0 - 0.5; // deterministic pseudo-noise
            (xv * 0.8).sin() * 2.0 + noise * 1.5
        })
        .collect();

    let df = df! {
        "x" => &x,
        "y" => &y,
    }?;

    // Linear smooth (default)
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth()
        .title("Linear Smooth (method = lm)")
        .save("smooth_lm.svg")?;

    println!("Saved smooth_lm.svg");

    // LOESS smooth
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth::default().loess(0.3))
        .title("LOESS Smooth (span = 0.3)")
        .save("smooth_loess.svg")?;

    println!("Saved smooth_loess.svg");
    Ok(())
}

pub fn geom_col(self) -> Self

Examples found in repository

examples/coord_flip.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

pub fn geom_col_with(self, geom: GeomCol) -> Self

pub fn geom_hline(self, yintercept: f64) -> Self

pub fn geom_hline_with(self, geom: GeomHline) -> Self

Add a horizontal reference line with custom styling (color/linetype/width).

pub fn geom_vline(self, xintercept: f64) -> Self

pub fn geom_vline_with(self, geom: GeomVline) -> Self

Add a vertical reference line with custom styling (color/linetype/width).

Examples found in repository

examples/supplier_leadtime.rs (lines 169-175)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

/// ECDF for one supplier — P(lead <= contract) reads straight off the curve.
fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

/// Compare suppliers: overlaid per-supplier densities against the contract line.
fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn geom_abline(self, slope: f64, intercept: f64) -> Self

pub fn geom_abline_with(self, geom: GeomAbline) -> Self

Add a slope/intercept reference line with custom styling.

pub fn geom_text(self) -> Self

pub fn geom_text_with(self, geom: GeomText) -> Self

pub fn geom_label(self) -> Self

pub fn geom_label_with(self, geom: GeomLabel) -> Self

pub fn geom_area(self) -> Self

Examples found in repository

examples/gallery.rs (line 410)

fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

pub fn geom_area_with(self, geom: GeomArea) -> Self

pub fn geom_ribbon(self) -> Self

Examples found in repository

examples/gallery.rs (line 380)

fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

pub fn geom_ribbon_with(self, geom: GeomRibbon) -> Self

pub fn geom_errorbar(self) -> Self

pub fn geom_errorbar_with(self, geom: GeomErrorbar) -> Self

pub fn geom_segment(self) -> Self

pub fn geom_segment_with(self, geom: GeomSegment) -> Self

pub fn geom_density(self) -> Self

Examples found in repository

examples/gallery.rs (line 268)

fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

examples/density.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

pub fn geom_density_with(self, geom: GeomDensity) -> Self

Examples found in repository

examples/supplier_leadtime.rs (lines 162-167)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

/// ECDF for one supplier — P(lead <= contract) reads straight off the curve.
fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

/// Compare suppliers: overlaid per-supplier densities against the contract line.
fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn geom_rug(self) -> Self

pub fn geom_rug_with(self, geom: GeomRug) -> Self

Examples found in repository

examples/supplier_leadtime.rs (lines 185-190)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

pub fn geom_jitter(self) -> Self

Examples found in repository

examples/gallery.rs (line 362)

fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

pub fn geom_jitter_with(self, geom: GeomJitter) -> Self

pub fn geom_path(self) -> Self

pub fn geom_path_with(self, geom: GeomPath) -> Self

pub fn stat_ellipse(self) -> Self

Add a confidence-ellipse layer (default 95%) as a path per group.

pub fn stat_ellipse_level(self, level: f64) -> Self

Add a confidence-ellipse layer at the given level (0, 1).

pub fn geom_step(self) -> Self

Examples found in repository

examples/supplier_leadtime.rs (line 222)

fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

pub fn geom_step_with(self, geom: GeomStep) -> Self

pub fn geom_freqpoly(self) -> Self

pub fn geom_freqpoly_with(self, geom: GeomFreqpoly) -> Self

pub fn geom_linerange(self) -> Self

pub fn geom_linerange_with(self, geom: GeomLinerange) -> Self

pub fn geom_pointrange(self) -> Self

pub fn geom_pointrange_with(self, geom: GeomPointrange) -> Self

pub fn geom_crossbar(self) -> Self

pub fn geom_crossbar_with(self, geom: GeomCrossbar) -> Self

pub fn geom_spoke(self) -> Self

pub fn geom_spoke_with(self, geom: GeomSpoke) -> Self

pub fn geom_rect(self) -> Self

pub fn geom_rect_with(self, geom: GeomRect) -> Self

pub fn geom_tile(self) -> Self

Examples found in repository

examples/gallery.rs (line 341)

fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

pub fn geom_tile_with(self, geom: GeomTile) -> Self

pub fn geom_raster(self) -> Self

Dense regular grid of filled cells (heatmap/raster) from x, y, fill.

pub fn geom_raster_with(self, geom: GeomRaster) -> Self

pub fn geom_polygon(self) -> Self

pub fn geom_polygon_with(self, geom: GeomPolygon) -> Self

pub fn geom_curve(self) -> Self

pub fn geom_curve_with(self, geom: GeomCurve) -> Self

pub fn geom_violin(self) -> Self

Examples found in repository

examples/gallery.rs (line 188)

fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

pub fn geom_violin_with(self, geom: GeomViolin) -> Self

pub fn geom_dotplot(self) -> Self

pub fn geom_dotplot_with(self, geom: GeomDotplot) -> Self

pub fn geom_qq(self) -> Self

pub fn geom_qq_with(self, geom: GeomQQ) -> Self

pub fn geom_qq_line(self) -> Self

pub fn geom_qq_line_with(self, geom: GeomQQLine) -> Self

pub fn geom_bin2d(self) -> Self

pub fn geom_bin2d_with(self, geom: GeomBin2d) -> Self

pub fn geom_hex(self) -> Self

Examples found in repository

examples/gallery.rs (line 320)

fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

pub fn geom_hex_with(self, geom: GeomHex) -> Self

pub fn geom_count(self) -> Self

pub fn geom_count_with(self, geom: GeomCount) -> Self

pub fn geom_contour(self) -> Self

pub fn geom_contour_with(self, geom: GeomContour) -> Self

pub fn geom_contour_filled(self) -> Self

Filled contour bands from gridded (x, y, z) data — draws polygons filled by band level. Pair with a continuous fill scale (e.g. scale_fill_viridis_c).

Examples found in repository

examples/gallery.rs (line 294)

fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

pub fn geom_density2d(self) -> Self

pub fn geom_density2d_with(self, geom: GeomDensity2d) -> Self

pub fn geom_blank(self) -> Self

pub fn stat(self, stat: impl Stat + 'static) -> Self

Override the stat for the most recently added layer.

Examples found in repository

examples/supplier_leadtime.rs (line 223)

fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

pub fn position(self, pos: impl Position + 'static) -> Self

Override the position for the most recently added layer.

pub fn layer_data(self, data: impl GGData) -> Self

Override the data for the most recently added layer.

Examples found in repository

examples/supplier_leadtime.rs (line 191)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

pub fn layer_aes(self, mapping: Aes) -> Self

Override the aesthetic mapping for the most recently added layer.

Examples found in repository

examples/supplier_leadtime.rs (line 192)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

pub fn show_legend(self, show: bool) -> Self

Control whether the most recently added layer contributes to the legend. true = always show, false = always hide, default (None) = auto.

pub fn scale_x_continuous(self, s: ScaleContinuous) -> Self

pub fn scale_y_continuous(self, s: ScaleContinuous) -> Self

pub fn scale_x_discrete(self, s: ScaleDiscrete) -> Self

pub fn scale_y_discrete(self, s: ScaleDiscrete) -> Self

pub fn scale_color(self, s: impl Scale + 'static) -> Self

pub fn scale_fill(self, s: impl Scale + 'static) -> Self

pub fn scale_color_manual(self, values: Vec<(&str, RGBAColor)>) -> Self

Examples found in repository

examples/color_palettes.rs (lines 62-68)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate grouped scatter data
    let groups = ["Alpha", "Beta", "Gamma", "Delta", "Epsilon"];
    let mut x_vals = Vec::new();
    let mut y_vals = Vec::new();
    let mut group_vals = Vec::new();

    for (gi, &group) in groups.iter().enumerate() {
        for j in 0..20 {
            let base_x = gi as f64 * 2.0 + 1.0;
            let base_y = (gi as f64 + 1.0) * 3.0;
            let r = ((gi * 20 + j) * 7 + 13) % 17;
            x_vals.push(base_x + (r as f64 / 17.0 - 0.5) * 2.0);
            y_vals.push(base_y + ((r * 3 + 5) % 11) as f64 / 11.0 * 4.0 - 2.0);
            group_vals.push(group);
        }
    }

    let df = df! {
        "x" => &x_vals,
        "y" => &y_vals,
        "group" => &group_vals,
    }?;

    // Viridis palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_viridis()
        .title("Viridis Palette")
        .save("palette_viridis.svg")?;

    println!("Saved palette_viridis.svg");

    // Brewer Set1 palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Brewer Set1 Palette")
        .save("palette_brewer_set1.svg")?;

    println!("Saved palette_brewer_set1.svg");

    // Brewer Dark2 palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Brewer Dark2 Palette")
        .save("palette_brewer_dark2.svg")?;

    println!("Saved palette_brewer_dark2.svg");

    // Manual colors
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_manual(vec![
            ("Alpha", RGBAColor::new(255, 0, 0)),
            ("Beta", RGBAColor::new(0, 180, 0)),
            ("Gamma", RGBAColor::new(0, 0, 255)),
            ("Delta", RGBAColor::new(255, 165, 0)),
            ("Epsilon", RGBAColor::new(128, 0, 128)),
        ])
        .title("Manual Color Scale")
        .save("palette_manual.svg")?;

    println!("Saved palette_manual.svg");
    Ok(())
}

pub fn scale_fill_manual(self, values: Vec<(&str, RGBAColor)>) -> Self

pub fn scale_color_viridis(self) -> Self

Examples found in repository

examples/color_palettes.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate grouped scatter data
    let groups = ["Alpha", "Beta", "Gamma", "Delta", "Epsilon"];
    let mut x_vals = Vec::new();
    let mut y_vals = Vec::new();
    let mut group_vals = Vec::new();

    for (gi, &group) in groups.iter().enumerate() {
        for j in 0..20 {
            let base_x = gi as f64 * 2.0 + 1.0;
            let base_y = (gi as f64 + 1.0) * 3.0;
            let r = ((gi * 20 + j) * 7 + 13) % 17;
            x_vals.push(base_x + (r as f64 / 17.0 - 0.5) * 2.0);
            y_vals.push(base_y + ((r * 3 + 5) % 11) as f64 / 11.0 * 4.0 - 2.0);
            group_vals.push(group);
        }
    }

    let df = df! {
        "x" => &x_vals,
        "y" => &y_vals,
        "group" => &group_vals,
    }?;

    // Viridis palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_viridis()
        .title("Viridis Palette")
        .save("palette_viridis.svg")?;

    println!("Saved palette_viridis.svg");

    // Brewer Set1 palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Brewer Set1 Palette")
        .save("palette_brewer_set1.svg")?;

    println!("Saved palette_brewer_set1.svg");

    // Brewer Dark2 palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Brewer Dark2 Palette")
        .save("palette_brewer_dark2.svg")?;

    println!("Saved palette_brewer_dark2.svg");

    // Manual colors
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_manual(vec![
            ("Alpha", RGBAColor::new(255, 0, 0)),
            ("Beta", RGBAColor::new(0, 180, 0)),
            ("Gamma", RGBAColor::new(0, 0, 255)),
            ("Delta", RGBAColor::new(255, 165, 0)),
            ("Epsilon", RGBAColor::new(128, 0, 128)),
        ])
        .title("Manual Color Scale")
        .save("palette_manual.svg")?;

    println!("Saved palette_manual.svg");
    Ok(())
}

pub fn scale_color_brewer(self, name: PaletteName) -> Self

Examples found in repository

examples/gallery.rs (line 59)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

/// The same plot rendered under every built-in theme.
fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

examples/supplier_leadtime.rs (line 277)

fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

examples/color_palettes.rs (line 42)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate grouped scatter data
    let groups = ["Alpha", "Beta", "Gamma", "Delta", "Epsilon"];
    let mut x_vals = Vec::new();
    let mut y_vals = Vec::new();
    let mut group_vals = Vec::new();

    for (gi, &group) in groups.iter().enumerate() {
        for j in 0..20 {
            let base_x = gi as f64 * 2.0 + 1.0;
            let base_y = (gi as f64 + 1.0) * 3.0;
            let r = ((gi * 20 + j) * 7 + 13) % 17;
            x_vals.push(base_x + (r as f64 / 17.0 - 0.5) * 2.0);
            y_vals.push(base_y + ((r * 3 + 5) % 11) as f64 / 11.0 * 4.0 - 2.0);
            group_vals.push(group);
        }
    }

    let df = df! {
        "x" => &x_vals,
        "y" => &y_vals,
        "group" => &group_vals,
    }?;

    // Viridis palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_viridis()
        .title("Viridis Palette")
        .save("palette_viridis.svg")?;

    println!("Saved palette_viridis.svg");

    // Brewer Set1 palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Brewer Set1 Palette")
        .save("palette_brewer_set1.svg")?;

    println!("Saved palette_brewer_set1.svg");

    // Brewer Dark2 palette
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Brewer Dark2 Palette")
        .save("palette_brewer_dark2.svg")?;

    println!("Saved palette_brewer_dark2.svg");

    // Manual colors
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("group"))
        .geom_point()
        .scale_color_manual(vec![
            ("Alpha", RGBAColor::new(255, 0, 0)),
            ("Beta", RGBAColor::new(0, 180, 0)),
            ("Gamma", RGBAColor::new(0, 0, 255)),
            ("Delta", RGBAColor::new(255, 165, 0)),
            ("Epsilon", RGBAColor::new(128, 0, 128)),
        ])
        .title("Manual Color Scale")
        .save("palette_manual.svg")?;

    println!("Saved palette_manual.svg");
    Ok(())
}

pub fn scale_color_gradient(self, low: RGBAColor, high: RGBAColor) -> Self

Examples found in repository

examples/continuous_color.rs (line 41)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate scatter data with a continuous variable for color
    let x: Vec<f64> = (0..200)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.3)
        })
        .collect();
    let y: Vec<f64> = (0..200)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.3)
        })
        .collect();
    let z: Vec<f64> = (0..200).map(|i| i as f64 * 0.05).collect();

    let df = df! {
        "x" => &x,
        "y" => &y,
        "z" => &z,
    }?;

    // Default blue-to-red gradient
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .title("Continuous Color (default gradient)")
        .xlab("X")
        .ylab("Y")
        .save("continuous_color.svg")?;

    println!("Saved continuous_color.svg");

    // Custom gradient: dark blue to yellow
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_gradient(RGBAColor::new(10, 30, 100), RGBAColor::new(255, 230, 50))
        .title("Continuous Color (custom gradient)")
        .xlab("X")
        .ylab("Y")
        .save("continuous_color_custom.svg")?;

    println!("Saved continuous_color_custom.svg");
    Ok(())
}

pub fn scale_fill_gradient(self, low: RGBAColor, high: RGBAColor) -> Self

pub fn scale_color_gradient2( self, low: RGBAColor, mid: RGBAColor, high: RGBAColor, ) -> Self

pub fn scale_fill_gradient2( self, low: RGBAColor, mid: RGBAColor, high: RGBAColor, ) -> Self

pub fn scale_fill_viridis(self) -> Self

pub fn scale_color_viridis_c(self) -> Self

Continuous viridis color scale (for numeric data).

Examples found in repository

examples/gallery.rs (line 219)

fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

pub fn scale_fill_viridis_c(self) -> Self

Continuous viridis fill scale (for numeric data).

Examples found in repository

examples/gallery.rs (line 295)

fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

pub fn scale_color_gradientn(self, stops: Vec<(f64, RGBAColor)>) -> Self

N-stop continuous color gradient.

pub fn scale_fill_gradientn(self, stops: Vec<(f64, RGBAColor)>) -> Self

N-stop continuous fill gradient.

pub fn scale_color_steps( self, low: RGBAColor, high: RGBAColor, n_bins: usize, ) -> Self

Binned (stepped) two-colour continuous colour scale — buckets the mapped variable into n_bins bins, each a discrete colour, with a stepped legend.

pub fn scale_color_stepsn(self, stops: Vec<RGBAColor>, n_bins: usize) -> Self

Binned N-stop continuous colour scale.

pub fn scale_color_fermenter(self, name: PaletteName, n_bins: usize) -> Self

Binned ColorBrewer colour scale (R’s scale_color_fermenter).

pub fn scale_fill_steps( self, low: RGBAColor, high: RGBAColor, n_bins: usize, ) -> Self

Binned (stepped) two-colour continuous fill scale.

pub fn scale_fill_fermenter(self, name: PaletteName, n_bins: usize) -> Self

Binned ColorBrewer fill scale.

pub fn scale_fill_brewer(self, name: PaletteName) -> Self

Examples found in repository

examples/gallery.rs (line 139)

fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

examples/supplier_leadtime.rs (line 276)

fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn scale_linetype_manual(self, values: Vec<(&str, Linetype)>) -> Self

pub fn scale_shape_manual(self, values: Vec<(&str, PointShape)>) -> Self

pub fn scale_color_grey(self) -> Self

pub fn scale_fill_grey(self) -> Self

pub fn scale_color_grey_with(self, s: ScaleColorGrey) -> Self

pub fn scale_fill_grey_with(self, s: ScaleColorGrey) -> Self

pub fn scale_x_reverse(self) -> Self

pub fn scale_y_reverse(self) -> Self

pub fn scale_x_datetime(self, s: ScaleDateTime) -> Self

pub fn scale_y_datetime(self, s: ScaleDateTime) -> Self

pub fn scale_size(self, s: ScaleSizeContinuous) -> Self

pub fn scale_alpha(self, s: ScaleAlphaContinuous) -> Self

pub fn xlim(self, min: f64, max: f64) -> Self

pub fn ylim(self, min: f64, max: f64) -> Self

pub fn scale_x_log10(self) -> Self

pub fn scale_y_log10(self) -> Self

Examples found in repository

examples/log_scale.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Exponential growth data (e.g., population, bacteria count)
    let year: Vec<f64> = (0..30).map(|i| 1990.0 + i as f64).collect();
    let count: Vec<f64> = (0..30)
        .map(|i| {
            let base = 100.0 * (1.15_f64).powi(i); // 15% growth per year
            let noise = ((i * 37 + 7) % 13) as f64 / 13.0 * 0.2 + 0.9;
            base * noise
        })
        .collect();

    let df = df! {
        "year" => &year,
        "count" => &count,
    }?;

    // Linear scale — exponential curve
    GGPlot::new(df.clone())
        .aes(Aes::new().x("year").y("count"))
        .geom_point()
        .geom_line()
        .title("Exponential Growth (Linear Scale)")
        .xlab("Year")
        .ylab("Count")
        .save("log_scale_linear.svg")?;

    println!("Saved log_scale_linear.svg");

    // Log10 y-axis — should appear roughly linear
    GGPlot::new(df)
        .aes(Aes::new().x("year").y("count"))
        .geom_point()
        .geom_line()
        .scale_y_log10()
        .title("Exponential Growth (Log10 Y Scale)")
        .xlab("Year")
        .ylab("Count (log10)")
        .save("log_scale_log10.svg")?;

    println!("Saved log_scale_log10.svg");
    Ok(())
}

pub fn scale_x_sqrt(self) -> Self

pub fn scale_y_sqrt(self) -> Self

pub fn scale_x_log2(self) -> Self

pub fn scale_y_log2(self) -> Self

pub fn scale_x_ln(self) -> Self

pub fn scale_y_ln(self) -> Self

pub fn scale_x_logit(self) -> Self

Logit-transformed x axis (for proportions in (0, 1)).

pub fn scale_y_logit(self) -> Self

pub fn scale_x_probit(self) -> Self

Probit-transformed x axis (inverse normal CDF, for proportions in (0, 1)).

pub fn scale_y_probit(self) -> Self

pub fn scale_x_pseudo_log(self) -> Self

Sign-preserving pseudo-log x axis (handles zero and negative values).

pub fn scale_y_pseudo_log(self) -> Self

pub fn scale_x_reciprocal(self) -> Self

Reciprocal (1/x) x axis.

pub fn scale_y_reciprocal(self) -> Self

pub fn scale_x_exp(self) -> Self

Exponential x axis (labels spaced logarithmically).

pub fn scale_y_exp(self) -> Self

pub fn scale_x_boxcox(self, lambda: f64) -> Self

Box–Cox x axis with the given lambda (x > 0).

pub fn scale_y_boxcox(self, lambda: f64) -> Self

pub fn facet_wrap(self, var: &str, ncol: Option<usize>) -> Self

Examples found in repository

examples/gallery.rs (line 243)

fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

examples/faceted.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate data with two grouping variables
    let sepal_length: Vec<f64> = (0..120)
        .map(|i| 4.0 + (i as f64) * 0.04 + (i as f64 * 0.5).sin() * 0.3)
        .collect();
    let sepal_width: Vec<f64> = (0..120)
        .map(|i| 2.0 + (i as f64) * 0.015 + (i as f64 * 0.3).cos() * 0.4)
        .collect();
    let species: Vec<&str> = (0..120)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();
    let region: Vec<&str> = (0..120)
        .map(|i| if i % 2 == 0 { "North" } else { "South" })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
        "region" => region,
    }?;

    // facet_wrap: one variable, automatic grid layout
    GGPlot::new(df.clone())
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .facet_wrap("species", Some(2))
        .title("Facet Wrap by Species")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("facet_wrap.svg")?;

    println!("Saved facet_wrap.svg");

    // facet_grid: two variables, row ~ col layout
    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .facet_grid(Some("region"), Some("species"))
        .title("Facet Grid: Region ~ Species")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("facet_grid.svg")?;

    println!("Saved facet_grid.svg");
    Ok(())
}

pub fn facet_wrap_free( self, var: &str, ncol: Option<usize>, scales: FacetScales, ) -> Self

pub fn facet_wrap_labeller( self, var: &str, ncol: Option<usize>, labeller: FacetLabeller, ) -> Self

pub fn facet_grid(self, row: Option<&str>, col: Option<&str>) -> Self

Examples found in repository

examples/faceted.rs (line 56)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate data with two grouping variables
    let sepal_length: Vec<f64> = (0..120)
        .map(|i| 4.0 + (i as f64) * 0.04 + (i as f64 * 0.5).sin() * 0.3)
        .collect();
    let sepal_width: Vec<f64> = (0..120)
        .map(|i| 2.0 + (i as f64) * 0.015 + (i as f64 * 0.3).cos() * 0.4)
        .collect();
    let species: Vec<&str> = (0..120)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();
    let region: Vec<&str> = (0..120)
        .map(|i| if i % 2 == 0 { "North" } else { "South" })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
        "region" => region,
    }?;

    // facet_wrap: one variable, automatic grid layout
    GGPlot::new(df.clone())
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .facet_wrap("species", Some(2))
        .title("Facet Wrap by Species")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("facet_wrap.svg")?;

    println!("Saved facet_wrap.svg");

    // facet_grid: two variables, row ~ col layout
    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .facet_grid(Some("region"), Some("species"))
        .title("Facet Grid: Region ~ Species")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("facet_grid.svg")?;

    println!("Saved facet_grid.svg");
    Ok(())
}

pub fn facet_grid_free( self, row: Option<&str>, col: Option<&str>, scales: FacetScales, ) -> Self

pub fn facet_grid_multi( self, row: Option<&str>, cols: &[&str], scales: FacetScales, space: FacetSpace, ) -> Self

facet_grid over multiple column variables (R’s rows ~ b + c): the columns become the combination of the given variables’ values. Also accepts free scales + proportional space for full parity.

pub fn facet_grid_space( self, row: Option<&str>, col: Option<&str>, scales: FacetScales, space: FacetSpace, ) -> Self

facet_grid with proportional panel sizing (R’s space =): panels are sized to their data range. Typically paired with free scales.

pub fn facet_grid_labeller( self, row: Option<&str>, col: Option<&str>, labeller: FacetLabeller, ) -> Self

pub fn coord_flip(self) -> Self

Examples found in repository

examples/coord_flip.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

pub fn coord_fixed(self, ratio: f64) -> Self

pub fn coord_trans( self, x: Option<ScaleTransform>, y: Option<ScaleTransform>, ) -> Self

Transform the coordinate space at draw time (R’s coord_trans) — stats are computed on raw data but drawn on non-linear axes. Pass a per-axis ScaleTransform (e.g. Some(ScaleTransform::Log10)), None to leave an axis linear.

pub fn coord_trans_y(self, y: ScaleTransform) -> Self

coord_trans on the y-axis only.

pub fn coord_trans_x(self, x: ScaleTransform) -> Self

coord_trans on the x-axis only.

pub fn coord_cartesian_zoom( self, xlim: Option<(f64, f64)>, ylim: Option<(f64, f64)>, ) -> Self

Zoom into a region without filtering data (unlike xlim/ylim which filter).

pub fn coord_polar(self) -> Self

pub fn coord_polar_with(self, coord: CoordPolar) -> Self

pub fn theme(self, theme: Theme) -> Self

Examples found in repository

examples/gallery.rs (line 443)

fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

pub fn axis_text_x_angle(self, degrees: f64) -> Self

Rotate the x-axis tick labels by degrees (R’s guides(x = guide_axis(angle = ...)) / axis.text.x = element_text(angle)). Useful for long category labels. Call after any theme_*() preset.

pub fn axis_text_y_angle(self, degrees: f64) -> Self

Rotate the y-axis tick labels by degrees.

pub fn axis_text_x_dodge(self, n: usize) -> Self

Stagger x-axis tick labels across n rows to avoid overlap (R’s guides(x = guide_axis(n.dodge = n))). 1 = no dodging.

pub fn legend_position_inside(self, x: f64, y: f64) -> Self

Set the brand/primary color used as the default for single-series geoms that have no color/fill aesthetic mapped. Composes with any theme — one render process can serve different tenants’ brands at render time. Place the legend inside the panel at panel-relative coordinates (0..1, 0..1) — (0,0) bottom-left, (1,1) top-right (R’s legend.position = c(x, y)).

pub fn primary_color(self, color: (u8, u8, u8)) -> Self

Examples found in repository

examples/gallery.rs (line 382)

fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

pub fn theme_minimal(self) -> Self

Examples found in repository

examples/gallery.rs (line 63)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

examples/supplier_leadtime.rs (line 200)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

/// ECDF for one supplier — P(lead <= contract) reads straight off the curve.
fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

/// Compare suppliers: overlaid per-supplier densities against the contract line.
fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn theme_bw(self) -> Self

Examples found in repository

examples/gallery.rs (line 90)

fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

examples/supplier_leadtime.rs (line 240)

fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

pub fn theme_gray(self) -> Self

pub fn theme_classic(self) -> Self

pub fn theme_linedraw(self) -> Self

pub fn theme_light(self) -> Self

pub fn theme_dark(self) -> Self

pub fn theme_void(self) -> Self

pub fn theme_update(self, update: ThemeUpdate) -> Self

Apply incremental theme modifications on top of the current theme. Like R’s + theme(axis.text.x = element_text(...)).

pub fn guides(self, guide: GuideLegend) -> Self

Configure legend guide (title, ncol, reverse).

pub fn labs(self, labels: Labels) -> Self

pub fn title(self, title: &str) -> Self

Examples found in repository

examples/bar_chart.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/coord_flip.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

examples/gallery.rs (line 60)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

/// The same plot rendered under every built-in theme.
fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

examples/annotations.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/density.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

examples/scatter.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

Additional examples can be found in:

• examples/loess_smooth.rs
• examples/histogram.rs
• examples/log_scale.rs
• examples/continuous_color.rs
• examples/faceted.rs
• examples/color_palettes.rs
• examples/supplier_leadtime.rs

pub fn tag(self, tag: &str) -> Self

Corner tag label (R’s labs(tag = ...)), drawn at the top-left — handy for labelling figure panels (“A”, “B”, …).

pub fn subtitle(self, subtitle: &str) -> Self

Examples found in repository

examples/supplier_leadtime.rs (line 197)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

/// ECDF for one supplier — P(lead <= contract) reads straight off the curve.
fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

/// Compare suppliers: overlaid per-supplier densities against the contract line.
fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn xlab(self, label: &str) -> Self

Examples found in repository

examples/bar_chart.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/coord_flip.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

examples/gallery.rs (line 61)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

examples/annotations.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/density.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

examples/scatter.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

Additional examples can be found in:

• examples/histogram.rs
• examples/log_scale.rs
• examples/continuous_color.rs
• examples/faceted.rs
• examples/supplier_leadtime.rs

pub fn ylab(self, label: &str) -> Self

Examples found in repository

examples/bar_chart.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/coord_flip.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

examples/gallery.rs (line 62)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

examples/annotations.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/density.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

examples/scatter.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

Additional examples can be found in:

• examples/histogram.rs
• examples/log_scale.rs
• examples/continuous_color.rs
• examples/faceted.rs
• examples/supplier_leadtime.rs

pub fn caption(self, caption: &str) -> Self

pub fn annotate(self, annotation: Annotation) -> Self

Add an annotation to the plot.

pub fn annotate_text(self, label: &str, x: f64, y: f64) -> Self

Add a text annotation at data coordinates.

Examples found in repository

examples/annotations.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/supplier_leadtime.rs (line 193)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

/// ECDF for one supplier — P(lead <= contract) reads straight off the curve.
fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

/// Compare suppliers: overlaid per-supplier densities against the contract line.
fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn annotate_rect(self, xmin: f64, xmax: f64, ymin: f64, ymax: f64) -> Self

Add a rectangle annotation at data coordinates.

Examples found in repository

examples/annotations.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

pub fn annotate_segment(self, x: f64, y: f64, xend: f64, yend: f64) -> Self

Add a segment annotation between data coordinates.

Examples found in repository

examples/annotations.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

pub fn try_build(self) -> Result<BuiltPlot, GGError>

Build the plot without rendering, returning errors on validation failure.

pub fn build(self) -> BuiltPlot

Build the plot without rendering (analogous to R’s ggplot_build()). Returns the fully computed BuiltPlot with layer data ready for inspection. Panics on validation errors — use try_build() for error handling.

pub fn save(self, path: &str) -> Result<(), GGError>

Build and save the plot to a file. Format determined by extension.

Examples found in repository

examples/bar_chart.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "fruit" => ["Apple", "Apple", "Apple", "Banana", "Banana",
                     "Cherry", "Cherry", "Cherry", "Cherry", "Date"],
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("fruit"))
        .geom_bar()
        .title("Fruit Counts")
        .xlab("Fruit")
        .ylab("Count")
        .save("bar_chart.svg")?;

    println!("Saved bar_chart.svg");
    Ok(())
}

examples/coord_flip.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = df! {
        "language" => ["Rust", "Python", "JavaScript", "Go", "TypeScript", "Java", "C++"],
        "satisfaction" => [92.0, 88.0, 85.0, 78.0, 82.0, 70.0, 75.0],
    }?;

    // Horizontal bar chart using coord_flip
    GGPlot::new(df)
        .aes(Aes::new().x("language").y("satisfaction"))
        .geom_col()
        .coord_flip()
        .title("Developer Satisfaction by Language")
        .xlab("Language")
        .ylab("Satisfaction Score")
        .save("coord_flip.svg")?;

    println!("Saved coord_flip.svg");
    Ok(())
}

examples/annotations.rs (line 29)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Sales data with a notable spike
    let month: Vec<f64> = (1..=12).map(|i| i as f64).collect();
    let sales = vec![
        120.0, 135.0, 150.0, 180.0, 210.0, 310.0, 280.0, 250.0, 190.0, 170.0, 155.0, 140.0,
    ];

    let df = df! {
        "month" => month,
        "sales" => sales,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("month").y("sales"))
        .geom_line()
        .geom_point()
        // Highlight the peak region
        .annotate_rect(4.5, 7.5, 100.0, 320.0)
        // Label the peak
        .annotate_text("Summer Peak", 6.0, 330.0)
        // Draw an arrow-like segment pointing to the max
        .annotate_segment(7.5, 330.0, 6.2, 312.0)
        .title("Monthly Sales with Annotations")
        .xlab("Month")
        .ylab("Sales ($)")
        .save("annotations.svg")?;

    println!("Saved annotations.svg");
    Ok(())
}

examples/density.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate two overlapping distributions using deterministic pseudo-random values
    let value: Vec<f64> = (0..200_u64)
        .map(|i| {
            let r = ((i.wrapping_mul(1103515245).wrapping_add(12345)) % (1 << 16)) as f64
                / (1u64 << 16) as f64;
            if i < 100 {
                3.0 + r * 4.0
            } else {
                5.0 + r * 4.0
            }
        })
        .collect();
    let group: Vec<&str> = (0..200)
        .map(|i| if i < 100 { "Group A" } else { "Group B" })
        .collect();

    let df = df! {
        "value" => value,
        "group" => group,
    }?;

    GGPlot::new(df)
        .aes(Aes::new().x("value").color("group"))
        .geom_density()
        .title("Density Plot by Group")
        .xlab("Value")
        .ylab("Density")
        .save("density.svg")?;

    println!("Saved density.svg");
    Ok(())
}

examples/scatter.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let sepal_length: Vec<f64> = (0..50).map(|i| 4.5 + i as f64 * 0.05).collect();
    let sepal_width: Vec<f64> = (0..50)
        .map(|i| 2.0 + (i as f64 * 0.3).sin() + i as f64 * 0.02)
        .collect();
    let species: Vec<&str> = (0..50)
        .map(|i| match i % 3 {
            0 => "setosa",
            1 => "versicolor",
            _ => "virginica",
        })
        .collect();

    let df = df! {
        "sepal_length" => sepal_length,
        "sepal_width" => sepal_width,
        "species" => species,
    }?;

    GGPlot::new(df)
        .aes(
            Aes::new()
                .x("sepal_length")
                .y("sepal_width")
                .color("species"),
        )
        .geom_point()
        .title("Iris Scatter Plot")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .save("scatter.svg")?;

    println!("Saved scatter.svg");
    Ok(())
}

examples/loess_smooth.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Generate noisy sine wave data
    let x: Vec<f64> = (0..80).map(|i| (i as f64) * 0.1).collect();
    let y: Vec<f64> = (0..80)
        .map(|i| {
            let xv = (i as f64) * 0.1;
            let noise = ((i * 17 + 3) % 11) as f64 / 11.0 - 0.5; // deterministic pseudo-noise
            (xv * 0.8).sin() * 2.0 + noise * 1.5
        })
        .collect();

    let df = df! {
        "x" => &x,
        "y" => &y,
    }?;

    // Linear smooth (default)
    GGPlot::new(df.clone())
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth()
        .title("Linear Smooth (method = lm)")
        .save("smooth_lm.svg")?;

    println!("Saved smooth_lm.svg");

    // LOESS smooth
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth::default().loess(0.3))
        .title("LOESS Smooth (span = 0.3)")
        .save("smooth_loess.svg")?;

    println!("Saved smooth_loess.svg");
    Ok(())
}

Additional examples can be found in:

• examples/histogram.rs
• examples/log_scale.rs
• examples/continuous_color.rs
• examples/faceted.rs
• examples/color_palettes.rs

pub fn save_with_size(self, path: &str, w: u32, h: u32) -> Result<(), GGError>

Build and save with custom dimensions.

Examples found in repository

examples/gallery.rs (line 64)

fn scatter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 150;
    let x: Vec<f64> = (0..n).map(|i| 4.5 + i as f64 * 0.02).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| 2.5 + (i as f64 * 0.15).sin() + (i % 3) as f64 * 0.6)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .scale_color_brewer(PaletteName::Set1)
        .title("Grouped Scatter")
        .xlab("Sepal Length")
        .ylab("Sepal Width")
        .theme_minimal()
        .save_with_size(&out("scatter"), W, H)?;
    Ok(())
}

/// Points overlaid with a LOESS trend line and confidence band.
fn smooth() -> Result<(), Box<dyn std::error::Error>> {
    let n = 120;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.1;
            (t * 0.6).sin() * 3.0 + t * 0.2 + ((i * 7919 % 100) as f64 / 100.0 - 0.5) * 1.5
        })
        .collect();

    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_point()
        .geom_smooth_with(GeomSmooth {
            method: SmoothMethod::Loess { span: 0.5 },
            ..Default::default()
        })
        .title("LOESS Smoothing")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("smooth"), W, H)?;
    Ok(())
}

/// Histogram of an approximately-normal sample.
fn histogram() -> Result<(), Box<dyn std::error::Error>> {
    let values: Vec<f64> = (0..1500)
        .map(|i: i32| {
            let r: f64 = (0..6)
                .map(|k| ((i * (1237 + k * 311) + 5678) % 1000) as f64 / 1000.0)
                .sum();
            (r - 3.0) * 2.0
        })
        .collect();

    let df = df! { "measurement" => values }?;
    GGPlot::new(df)
        .aes(Aes::new().x("measurement"))
        .geom_histogram_with(GeomHistogram {
            bins: 30,
            ..Default::default()
        })
        .title("Histogram")
        .xlab("Value")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("histogram"), W, H)?;
    Ok(())
}

/// Bar chart of category counts with a fill palette.
fn bar() -> Result<(), Box<dyn std::error::Error>> {
    let mut fruit: Vec<&str> = Vec::new();
    for (f, c) in [
        ("Apple", 8),
        ("Banana", 5),
        ("Cherry", 11),
        ("Date", 3),
        ("Elder", 7),
    ] {
        for _ in 0..c {
            fruit.push(f);
        }
    }
    let df = df! { "fruit" => fruit }?;
    GGPlot::new(df)
        .aes(Aes::new().x("fruit").fill("fruit"))
        .geom_bar()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Bar Chart")
        .xlab("Fruit")
        .ylab("Count")
        .theme_minimal()
        .save_with_size(&out("bar"), W, H)?;
    Ok(())
}

/// Grouped boxplots.
fn boxplot() -> Result<(), Box<dyn std::error::Error>> {
    let n = 240;
    let group: Vec<&str> = (0..n).map(|i| ["A", "B", "C", "D"][i % 4]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 4) as f64 * 1.5;
            base + (i as f64 * 0.4).sin() * 1.2 + ((i * 6151 % 100) as f64 / 100.0 - 0.5) * 2.0
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value"))
        .geom_boxplot_with(GeomBoxplot {
            fill: (70, 130, 180),
            ..Default::default()
        })
        .title("Boxplot")
        .xlab("Group")
        .ylab("Value")
        .theme_bw()
        .save_with_size(&out("boxplot"), W, H)?;
    Ok(())
}

/// Violin plots of grouped distributions.
fn violin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 360;
    let group: Vec<&str> = (0..n).map(|i| ["X", "Y", "Z"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let g = (i % 3) as f64;
            g * 2.0 + (i as f64 * 0.5).sin() * 1.5 + ((i * 4231 % 100) as f64 / 100.0 - 0.5) * 2.5
        })
        .collect();

    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").fill("group"))
        .geom_violin()
        .scale_fill_brewer(PaletteName::Accent)
        .title("Violin")
        .xlab("Group")
        .ylab("Value")
        .theme_minimal()
        .save_with_size(&out("violin"), W, H)?;
    Ok(())
}

/// Spiral scatter coloured by a continuous variable (viridis).
fn continuous_color() -> Result<(), Box<dyn std::error::Error>> {
    let n = 400;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.cos() * (1.0 + t * 0.12)
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64 * 0.05;
            t.sin() * (1.0 + t * 0.12)
        })
        .collect();
    let z: Vec<f64> = (0..n).map(|i| i as f64 * 0.05).collect();

    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("z"))
        .geom_point()
        .scale_color_viridis_c()
        .title("Continuous Color (viridis)")
        .xlab("x")
        .ylab("y")
        .theme_minimal()
        .save_with_size(&out("continuous_color"), W, H)?;
    Ok(())
}

/// Faceted scatter, one panel per group.
fn facet() -> Result<(), Box<dyn std::error::Error>> {
    let n = 180;
    let x: Vec<f64> = (0..n).map(|i| (i as f64 * 0.1).cos() * 3.0).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() * 3.0 + (i % 3) as f64)
        .collect();
    let species: Vec<&str> = (0..n)
        .map(|i| ["setosa", "versicolor", "virginica"][i % 3])
        .collect();

    let df = df! { "x" => x, "y" => y, "species" => species }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").color("species"))
        .geom_point()
        .facet_wrap("species", Some(3))
        .scale_color_brewer(PaletteName::Set1)
        .title("Facet Wrap")
        .xlab("x")
        .ylab("y")
        .theme_bw()
        .save_with_size(&out("facet"), W, H)?;
    Ok(())
}

/// Overlapping density curves by group.
fn density() -> Result<(), Box<dyn std::error::Error>> {
    let n = 600;
    let group: Vec<&str> = (0..n).map(|i| ["Group 1", "Group 2"][i % 2]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let shift = (i % 2) as f64 * 2.5;
            let t = i as f64 * 0.05;
            shift + (t.sin() + (t * 1.7).cos()) + ((i * 3319 % 100) as f64 / 100.0 - 0.5) * PI
        })
        .collect();

    let df = df! { "value" => value, "group" => group }?;
    GGPlot::new(df)
        .aes(Aes::new().x("value").fill("group").color("group"))
        .geom_density()
        .scale_fill_brewer(PaletteName::Set1)
        .scale_color_brewer(PaletteName::Set1)
        .title("Density by Group")
        .xlab("Value")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("density"), W, H)?;
    Ok(())
}

/// Filled contour bands from a gridded surface.
fn contour_filled() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut z) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..40 {
        for j in 0..40 {
            let xv = i as f64 * 0.25 - 5.0;
            let yv = j as f64 * 0.25 - 5.0;
            x.push(xv);
            y.push(yv);
            z.push((xv * 0.6).sin() * (yv * 0.6).cos() + (-(xv * xv + yv * yv) / 30.0).exp());
        }
    }
    let df = df! { "x" => x, "y" => y, "z" => z }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_contour_filled()
        .scale_fill_viridis_c()
        .title("Filled Contours")
        .theme_minimal()
        .save_with_size(&out("contour_filled"), W, H)?;
    Ok(())
}

/// Hexagonal binning of a 2-D point cloud.
fn hexbin() -> Result<(), Box<dyn std::error::Error>> {
    let n = 4000;
    let x: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).sin() * 2.0 + ((i * 7919 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let y: Vec<f64> = (0..n)
        .map(|i| {
            let t = i as f64;
            (t * 0.017).cos() * 2.0 + ((i * 6323 % 1000) as f64 / 1000.0 - 0.5) * 3.0
        })
        .collect();
    let df = df! { "x" => x, "y" => y }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y"))
        .geom_hex()
        .scale_fill_viridis_c()
        .title("Hex Binning")
        .theme_minimal()
        .save_with_size(&out("hexbin"), W, H)?;
    Ok(())
}

/// Heatmap of a gridded value with `geom_tile`.
fn heatmap() -> Result<(), Box<dyn std::error::Error>> {
    let (mut x, mut y, mut fill) = (Vec::new(), Vec::new(), Vec::new());
    for i in 0..14 {
        for j in 0..14 {
            x.push(i as f64);
            y.push(j as f64);
            fill.push((i as f64 * 0.5).sin() * (j as f64 * 0.5).cos());
        }
    }
    let df = df! { "x" => x, "y" => y, "fill" => fill }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("fill"))
        .geom_tile()
        .scale_fill_viridis_c()
        .title("Heatmap")
        .theme_minimal()
        .save_with_size(&out("heatmap"), W, H)?;
    Ok(())
}

/// Jittered categorical scatter (`geom_jitter`).
fn jitter() -> Result<(), Box<dyn std::error::Error>> {
    let n = 300;
    let group: Vec<&str> = (0..n).map(|i| ["Control", "Low", "High"][i % 3]).collect();
    let value: Vec<f64> = (0..n)
        .map(|i| {
            let base = (i % 3) as f64 * 1.5;
            base + ((i * 5701 % 1000) as f64 / 1000.0 - 0.5) * 2.0
        })
        .collect();
    let df = df! { "group" => group, "value" => value }?;
    GGPlot::new(df)
        .aes(Aes::new().x("group").y("value").color("group"))
        .geom_jitter()
        .scale_color_brewer(PaletteName::Dark2)
        .title("Jittered Points")
        .theme_minimal()
        .save_with_size(&out("jitter"), W, H)?;
    Ok(())
}

/// A confidence band (`geom_ribbon`) under a line.
fn ribbon() -> Result<(), Box<dyn std::error::Error>> {
    let n = 80;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.15).collect();
    let y: Vec<f64> = x.iter().map(|v| v.sin() + v * 0.1).collect();
    let ymin: Vec<f64> = y.iter().map(|v| v - 0.4).collect();
    let ymax: Vec<f64> = y.iter().map(|v| v + 0.4).collect();
    let df = df! { "x" => x, "y" => y, "ymin" => ymin, "ymax" => ymax }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").ymin("ymin").ymax("ymax"))
        .geom_ribbon()
        .geom_line()
        .primary_color((49, 130, 189))
        .title("Ribbon + Line")
        .theme_minimal()
        .save_with_size(&out("ribbon"), W, H)?;
    Ok(())
}

/// Stacked areas by group.
fn area_stack() -> Result<(), Box<dyn std::error::Error>> {
    let n = 40;
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut g = Vec::new();
    for grp in ["North", "South", "East"] {
        for i in 0..n {
            x.push(i as f64);
            let base = match grp {
                "North" => 2.0,
                "South" => 3.0,
                _ => 1.5,
            };
            y.push(base + (i as f64 * 0.2).sin().abs() * base);
            g.push(grp);
        }
    }
    let df = df! { "x" => x, "y" => y, "g" => g }?;
    GGPlot::new(df)
        .aes(Aes::new().x("x").y("y").fill("g"))
        .geom_area()
        .scale_fill_brewer(PaletteName::Set2)
        .title("Stacked Area")
        .theme_minimal()
        .save_with_size(&out("area"), W, H)?;
    Ok(())
}

/// The same plot rendered under every built-in theme.
fn themes() -> Result<(), Box<dyn std::error::Error>> {
    let n = 90;
    let x: Vec<f64> = (0..n).map(|i| i as f64 * 0.1).collect();
    let y: Vec<f64> = (0..n)
        .map(|i| (i as f64 * 0.1).sin() + (i % 3) as f64 * 0.5)
        .collect();
    let g: Vec<&str> = (0..n).map(|i| ["A", "B", "C"][i % 3]).collect();
    let df = df! { "x" => x, "y" => y, "g" => g }?;

    type ThemeFn = fn() -> Theme;
    let variants: [(&str, ThemeFn); 8] = [
        ("gray", theme_gray),
        ("bw", theme_bw),
        ("minimal", theme_minimal),
        ("classic", theme_classic),
        ("light", theme_light),
        ("dark", theme_dark),
        ("linedraw", theme_linedraw),
        ("void", theme_void),
    ];
    for (name, make) in variants {
        GGPlot::new(df.clone())
            .aes(Aes::new().x("x").y("y").color("g"))
            .geom_point()
            .theme(make())
            .scale_color_brewer(PaletteName::Dark2)
            .title(&format!("theme_{name}"))
            .save_with_size(&out(&format!("theme_{name}")), TW, TH)?;
    }
    Ok(())
}

examples/supplier_leadtime.rs (line 201)

fn detail(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let mine: Vec<&Po> = rows.iter().filter(|p| p.supplier == name).collect();

    let attributable: Vec<f64> = mine
        .iter()
        .filter(|p| p.attributable)
        .map(|p| p.lead)
        .collect();
    let p90 = percentile(attributable.clone(), 0.90);

    let dens_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];
    let excused_data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        mine.iter()
            .filter(|p| !p.attributable)
            .map(|p| Value::Float(p.lead))
            .collect(),
    )];

    GGPlot::new(dens_data)
        .aes(Aes::new().x("lead"))
        .geom_density_with(GeomDensity {
            fill: TEAL,
            color: (20, 110, 98),
            alpha: 0.45,
            line_width: 1.5,
        })
        // SLA threshold — mass to the left is the on-time share.
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // p90 — the number to size safety stock against.
        .geom_vline_with(GeomVline {
            xintercept: p90,
            color: P90_BLUE,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        // Excused deliveries, shown distinctly and kept out of the density.
        .geom_rug_with(GeomRug {
            color: MUTED,
            alpha: 0.7,
            length: 0.04,
            sides: "b".to_string(),
        })
        .layer_data(excused_data)
        .layer_aes(Aes::new().x("lead"))
        .annotate_text(&format!("contract {CONTRACT:.0}d"), CONTRACT + 1.0, 0.075)
        .annotate_text(&format!("p90 {p90:.0}d"), p90 + 1.0, 0.06)
        .annotate_text("<- excused (external)", 48.0, 0.008)
        .title(&format!("{name} — lead-time distribution"))
        .subtitle("attributable deliveries only; excused shown as rug")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime"), W, H)?;
    Ok(())
}

/// ECDF for one supplier — P(lead <= contract) reads straight off the curve.
fn ecdf(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let name = "Meridian Components";
    let attributable: Vec<f64> = rows
        .iter()
        .filter(|p| p.supplier == name && p.attributable)
        .map(|p| p.lead)
        .collect();
    let on_time =
        attributable.iter().filter(|&&l| l <= CONTRACT).count() as f64 / attributable.len() as f64;
    let data: Vec<(String, Vec<Value>)> = vec![(
        "lead".to_string(),
        attributable.iter().map(|v| Value::Float(*v)).collect(),
    )];

    GGPlot::new(data)
        .aes(Aes::new().x("lead"))
        .geom_step()
        .stat(StatEcdf)
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.5,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .annotate_text(
            &format!("on-time rate {:.0}%", on_time * 100.0),
            CONTRACT + 1.0,
            0.15,
        )
        .title(&format!("{name} — on-time reliability (ECDF)"))
        .subtitle("cumulative share at the contract line = P(lead <= 30d)")
        .xlab("Actual lead time (days)")
        .ylab("Cumulative share")
        .theme_bw()
        .save_with_size(&out("supplier_leadtime_ecdf"), W, H)?;
    Ok(())
}

/// Compare suppliers: overlaid per-supplier densities against the contract line.
fn compare(rows: &[Po]) -> Result<(), Box<dyn std::error::Error>> {
    let lead: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Float(p.lead))
        .collect();
    let supplier: Vec<Value> = rows
        .iter()
        .filter(|p| p.attributable)
        .map(|p| Value::Str(p.supplier.to_string()))
        .collect();
    let data: Vec<(String, Vec<Value>)> = vec![
        ("lead".to_string(), lead),
        ("supplier".to_string(), supplier),
    ];

    GGPlot::new(data)
        .aes(Aes::new().x("lead").fill("supplier").color("supplier"))
        .geom_density_with(GeomDensity {
            alpha: 0.35,
            line_width: 1.2,
            ..Default::default()
        })
        .geom_vline_with(GeomVline {
            xintercept: CONTRACT,
            color: CONTRACT_RED,
            width: 1.2,
            linetype: Linetype::Dashed,
            alpha: 1.0,
        })
        .scale_fill_brewer(PaletteName::Dark2)
        .scale_color_brewer(PaletteName::Dark2)
        .annotate_text("contract", CONTRACT + 1.0, 0.005)
        .title("Lead-time distributions by supplier")
        .subtitle("attributable deliveries; dashed line = contracted lead time")
        .xlab("Actual lead time (days)")
        .ylab("Density")
        .theme_minimal()
        .save_with_size(&out("supplier_leadtime_compare"), W, H)?;
    Ok(())
}

pub fn render_svg(self) -> Result<String, GGError>

Render the plot to an in-memory SVG document (default 800x600).

Unlike save, this writes nothing to disk — handy for serving charts from a web/MCP service.

pub fn render_svg_with_size(self, w: u32, h: u32) -> Result<String, GGError>

Render the plot to an in-memory SVG document with custom dimensions.

pub fn render_png(self) -> Result<Vec<u8>, GGError>

Render the plot to in-memory PNG bytes (default 800x600).

Returns a fully-encoded PNG, ready to write to an HTTP response or embed as a data URI — no temp files involved.

pub fn render_png_with_size(self, w: u32, h: u32) -> Result<Vec<u8>, GGError>

Render the plot to in-memory PNG bytes with custom dimensions.

pub fn ggsave( self, path: &str, width_inches: f64, height_inches: f64, dpi: f64, ) -> Result<(), GGError>

Save with physical dimensions (inches) and DPI.