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 46)

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 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 47)

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 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 48)

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(())
}

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/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 128)

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 99-102)

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 152-155)

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 73-76)

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

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

pub fn geom_ribbon(self) -> Self

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 258)

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

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 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

pub fn geom_tile_with(self, geom: GeomTile) -> 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 178)

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

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_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 49)

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/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 209)

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).

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_fill_brewer(self, name: PaletteName) -> Self

Examples found in repository

examples/gallery.rs (line 129)

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/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 facet_wrap(self, var: &str, ncol: Option<usize>) -> Self

Examples found in repository

examples/gallery.rs (line 233)

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_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_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

pub fn primary_color(self, color: (u8, u8, u8)) -> 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.

pub fn theme_minimal(self) -> Self

Examples found in repository

examples/gallery.rs (line 53)

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/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 80)

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 50)

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 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 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 51)

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 52)

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 54)

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/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.