Struct Aes 

pub struct Aes {
    pub mappings: Vec<AesMapping>,
    pub after_scale: Vec<AfterScaleSpec>,
}

Builder for aesthetic mappings.

Fields

mappings: Vec<AesMapping>

after_scale: Vec<AfterScaleSpec>

Post-scale color derivations (after_scale).

Implementations

impl Aes

pub fn new() -> Self

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 (line 25)

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 after_scale_fill_from_color(self, lightness: f64) -> Self

Set fill to the mapped color with adjusted lightness (R’s aes(fill = after_scale(...))). lightness in -1.0..=1.0: positive lightens toward white, negative darkens toward black.

pub fn after_scale_color_from_fill(self, lightness: f64) -> Self

Set color to the mapped fill with adjusted lightness — useful for a darker border around a filled shape (color = after_scale(darken(fill))).

pub fn stage(self, aesthetic: Aesthetic, start: &str, after_stat: &str) -> Self

stage(start, after_stat): map aesthetic from start before the stat and re-map it from after_stat afterwards (R’s stage()).

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

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 (line 26)

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 y(self, col: &str) -> Self

Examples found in repository

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

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/scatter.rs (line 27)

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

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

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

Additional examples can be found in:

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

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

Examples found in repository

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/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 (line 28)

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/continuous_color.rs (line 28)

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

examples/supplier_leadtime.rs (line 263)

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/faceted.rs (line 36)

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

Additional examples can be found in:

• examples/color_palettes.rs

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

Examples found in repository

examples/gallery.rs (line 127)

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

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 size(self, col: &str) -> Self

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Map a stat-computed column to the y aesthetic (e.g., after_stat_y("density")).

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

Map a stat-computed column to the x aesthetic.

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

Map a stat-computed column to the fill aesthetic.

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

Map a stat-computed column to the color aesthetic.

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

Map a stat-computed column to the size aesthetic.

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

Map a stat-computed column to the alpha aesthetic.

pub fn get_mapping(&self, aes: &Aesthetic) -> Option<&str>

Get the column mapped to a specific aesthetic.

pub fn merge(&self, other: &Aes) -> Aes

Merge another Aes into this one. The other’s mappings override on conflict.

Trait Implementations

impl Clone for Aes

fn clone(&self) -> Aes

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Aes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Aes

fn default() -> Aes

Returns the “default value” for a type.