Struct Axes 

pub struct Axes {
    pub title: Option<String>,
    pub x_config: AxisConfig,
    pub y_config: AxisConfig,
    pub legend_position: LegendPosition,
    pub show_legend: bool,
    /* private fields */
}

A single plot area containing axes, series, and legend configuration.

Fields

title: Option<String>

Title for this plot area.

x_config: AxisConfig

X-axis configuration.

y_config: AxisConfig

Y-axis configuration.

legend_position: LegendPosition

Legend position.

show_legend: bool

Whether to show the legend.

Implementations

impl Axes

pub fn new() -> Self

Create a new axes.

pub fn title(&mut self, title: impl Into<String>) -> &mut Self

Set the plot title.

pub fn x_label(&mut self, label: impl Into<String>) -> &mut Self

Set the X-axis label.

Examples found in repository

examples/training_curves.rs (line 53)

fn main() -> Result<()> {
    // ── Simulate training curves ─────────────────────────────────────
    let epochs: Vec<f64> = (1..=50).map(f64::from).collect();

    // Training loss: exponential decay + noise
    let mut rng = SimpleRng::new(42);
    let train_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| 2.0 * (-e / 15.0).exp() + 0.05 + rng.normal() * 0.02)
        .collect();

    // Validation loss: decays slower, starts overfitting around epoch 30
    let val_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 2.0 * (-e / 20.0).exp() + 0.1;
            let overfit = if e > 30.0 { (e - 30.0) * 0.005 } else { 0.0 };
            base + overfit + rng.normal() * 0.03
        })
        .collect();

    // Training accuracy: rises from ~50% to ~98%
    let train_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| (0.98 - 0.48 * (-e / 12.0).exp()).min(1.0) + rng.normal() * 0.01)
        .collect();

    // Validation accuracy: rises but plateaus earlier
    let val_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 0.93 - 0.43 * (-e / 18.0).exp();
            let overfit = if e > 30.0 { -(e - 30.0) * 0.002 } else { 0.0 };
            (base + overfit + rng.normal() * 0.015).min(1.0)
        })
        .collect();

    // ── Plot 1: Loss curves ──────────────────────────────────────────
    let mut fig = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Loss");

    let ax = fig.add_axes();
    ax.x_label("Epoch").y_label("Loss");
    ax.line(&epochs, &train_loss)
        .label("Train Loss")
        .color(Color::from_hex("#1f77b4").unwrap().into())
        .width(2.0)
        .done();
    ax.line(&epochs, &val_loss)
        .label("Val Loss")
        .color(Color::from_hex("#ff7f0e").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig.save_svg("training_loss.svg")?;
    println!("Saved training_loss.svg");

    // ── Plot 2: Accuracy curves ──────────────────────────────────────
    let mut fig2 = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Accuracy");

    let ax2 = fig2.add_axes();
    ax2.x_label("Epoch").y_label("Accuracy").y_range(0.4, 1.05);
    ax2.line(&epochs, &train_acc)
        .label("Train Accuracy")
        .color(Color::from_hex("#2ca02c").unwrap().into())
        .width(2.0)
        .done();
    ax2.line(&epochs, &val_acc)
        .label("Val Accuracy")
        .color(Color::from_hex("#d62728").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig2.save_svg("training_accuracy.svg")?;
    println!("Saved training_accuracy.svg");

    Ok(())
}

pub fn y_label(&mut self, label: impl Into<String>) -> &mut Self

Set the Y-axis label.

Examples found in repository

examples/training_curves.rs (line 53)

fn main() -> Result<()> {
    // ── Simulate training curves ─────────────────────────────────────
    let epochs: Vec<f64> = (1..=50).map(f64::from).collect();

    // Training loss: exponential decay + noise
    let mut rng = SimpleRng::new(42);
    let train_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| 2.0 * (-e / 15.0).exp() + 0.05 + rng.normal() * 0.02)
        .collect();

    // Validation loss: decays slower, starts overfitting around epoch 30
    let val_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 2.0 * (-e / 20.0).exp() + 0.1;
            let overfit = if e > 30.0 { (e - 30.0) * 0.005 } else { 0.0 };
            base + overfit + rng.normal() * 0.03
        })
        .collect();

    // Training accuracy: rises from ~50% to ~98%
    let train_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| (0.98 - 0.48 * (-e / 12.0).exp()).min(1.0) + rng.normal() * 0.01)
        .collect();

    // Validation accuracy: rises but plateaus earlier
    let val_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 0.93 - 0.43 * (-e / 18.0).exp();
            let overfit = if e > 30.0 { -(e - 30.0) * 0.002 } else { 0.0 };
            (base + overfit + rng.normal() * 0.015).min(1.0)
        })
        .collect();

    // ── Plot 1: Loss curves ──────────────────────────────────────────
    let mut fig = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Loss");

    let ax = fig.add_axes();
    ax.x_label("Epoch").y_label("Loss");
    ax.line(&epochs, &train_loss)
        .label("Train Loss")
        .color(Color::from_hex("#1f77b4").unwrap().into())
        .width(2.0)
        .done();
    ax.line(&epochs, &val_loss)
        .label("Val Loss")
        .color(Color::from_hex("#ff7f0e").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig.save_svg("training_loss.svg")?;
    println!("Saved training_loss.svg");

    // ── Plot 2: Accuracy curves ──────────────────────────────────────
    let mut fig2 = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Accuracy");

    let ax2 = fig2.add_axes();
    ax2.x_label("Epoch").y_label("Accuracy").y_range(0.4, 1.05);
    ax2.line(&epochs, &train_acc)
        .label("Train Accuracy")
        .color(Color::from_hex("#2ca02c").unwrap().into())
        .width(2.0)
        .done();
    ax2.line(&epochs, &val_acc)
        .label("Val Accuracy")
        .color(Color::from_hex("#d62728").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig2.save_svg("training_accuracy.svg")?;
    println!("Saved training_accuracy.svg");

    Ok(())
}

pub fn x_range(&mut self, min: f64, max: f64) -> &mut Self

Set the X-axis range manually.

pub fn y_range(&mut self, min: f64, max: f64) -> &mut Self

Set the Y-axis range manually.

Examples found in repository

examples/training_curves.rs (line 75)

fn main() -> Result<()> {
    // ── Simulate training curves ─────────────────────────────────────
    let epochs: Vec<f64> = (1..=50).map(f64::from).collect();

    // Training loss: exponential decay + noise
    let mut rng = SimpleRng::new(42);
    let train_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| 2.0 * (-e / 15.0).exp() + 0.05 + rng.normal() * 0.02)
        .collect();

    // Validation loss: decays slower, starts overfitting around epoch 30
    let val_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 2.0 * (-e / 20.0).exp() + 0.1;
            let overfit = if e > 30.0 { (e - 30.0) * 0.005 } else { 0.0 };
            base + overfit + rng.normal() * 0.03
        })
        .collect();

    // Training accuracy: rises from ~50% to ~98%
    let train_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| (0.98 - 0.48 * (-e / 12.0).exp()).min(1.0) + rng.normal() * 0.01)
        .collect();

    // Validation accuracy: rises but plateaus earlier
    let val_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 0.93 - 0.43 * (-e / 18.0).exp();
            let overfit = if e > 30.0 { -(e - 30.0) * 0.002 } else { 0.0 };
            (base + overfit + rng.normal() * 0.015).min(1.0)
        })
        .collect();

    // ── Plot 1: Loss curves ──────────────────────────────────────────
    let mut fig = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Loss");

    let ax = fig.add_axes();
    ax.x_label("Epoch").y_label("Loss");
    ax.line(&epochs, &train_loss)
        .label("Train Loss")
        .color(Color::from_hex("#1f77b4").unwrap().into())
        .width(2.0)
        .done();
    ax.line(&epochs, &val_loss)
        .label("Val Loss")
        .color(Color::from_hex("#ff7f0e").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig.save_svg("training_loss.svg")?;
    println!("Saved training_loss.svg");

    // ── Plot 2: Accuracy curves ──────────────────────────────────────
    let mut fig2 = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Accuracy");

    let ax2 = fig2.add_axes();
    ax2.x_label("Epoch").y_label("Accuracy").y_range(0.4, 1.05);
    ax2.line(&epochs, &train_acc)
        .label("Train Accuracy")
        .color(Color::from_hex("#2ca02c").unwrap().into())
        .width(2.0)
        .done();
    ax2.line(&epochs, &val_acc)
        .label("Val Accuracy")
        .color(Color::from_hex("#d62728").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig2.save_svg("training_accuracy.svg")?;
    println!("Saved training_accuracy.svg");

    Ok(())
}

pub fn x_axis(&mut self, config: AxisConfig) -> &mut Self

Set X-axis config.

pub fn y_axis(&mut self, config: AxisConfig) -> &mut Self

Set Y-axis config.

pub fn legend(&mut self, position: LegendPosition) -> &mut Self

Set legend position.

pub fn line(&mut self, x: &[f64], y: &[f64]) -> LineBuilder<'_>

Add a line series and return a builder for customization.

Examples found in repository

examples/training_curves.rs (line 54)

fn main() -> Result<()> {
    // ── Simulate training curves ─────────────────────────────────────
    let epochs: Vec<f64> = (1..=50).map(f64::from).collect();

    // Training loss: exponential decay + noise
    let mut rng = SimpleRng::new(42);
    let train_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| 2.0 * (-e / 15.0).exp() + 0.05 + rng.normal() * 0.02)
        .collect();

    // Validation loss: decays slower, starts overfitting around epoch 30
    let val_loss: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 2.0 * (-e / 20.0).exp() + 0.1;
            let overfit = if e > 30.0 { (e - 30.0) * 0.005 } else { 0.0 };
            base + overfit + rng.normal() * 0.03
        })
        .collect();

    // Training accuracy: rises from ~50% to ~98%
    let train_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| (0.98 - 0.48 * (-e / 12.0).exp()).min(1.0) + rng.normal() * 0.01)
        .collect();

    // Validation accuracy: rises but plateaus earlier
    let val_acc: Vec<f64> = epochs
        .iter()
        .map(|&e| {
            let base = 0.93 - 0.43 * (-e / 18.0).exp();
            let overfit = if e > 30.0 { -(e - 30.0) * 0.002 } else { 0.0 };
            (base + overfit + rng.normal() * 0.015).min(1.0)
        })
        .collect();

    // ── Plot 1: Loss curves ──────────────────────────────────────────
    let mut fig = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Loss");

    let ax = fig.add_axes();
    ax.x_label("Epoch").y_label("Loss");
    ax.line(&epochs, &train_loss)
        .label("Train Loss")
        .color(Color::from_hex("#1f77b4").unwrap().into())
        .width(2.0)
        .done();
    ax.line(&epochs, &val_loss)
        .label("Val Loss")
        .color(Color::from_hex("#ff7f0e").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig.save_svg("training_loss.svg")?;
    println!("Saved training_loss.svg");

    // ── Plot 2: Accuracy curves ──────────────────────────────────────
    let mut fig2 = Figure::new()
        .size(750.0, 500.0)
        .title("Training & Validation Accuracy");

    let ax2 = fig2.add_axes();
    ax2.x_label("Epoch").y_label("Accuracy").y_range(0.4, 1.05);
    ax2.line(&epochs, &train_acc)
        .label("Train Accuracy")
        .color(Color::from_hex("#2ca02c").unwrap().into())
        .width(2.0)
        .done();
    ax2.line(&epochs, &val_acc)
        .label("Val Accuracy")
        .color(Color::from_hex("#d62728").unwrap().into())
        .width(2.0)
        .dash(&[8.0, 4.0])
        .done();

    fig2.save_svg("training_accuracy.svg")?;
    println!("Saved training_accuracy.svg");

    Ok(())
}

pub fn scatter(&mut self, x: &[f64], y: &[f64]) -> ScatterBuilder<'_>

Add a scatter series and return a builder for customization.

pub fn bar(&mut self, x: &[f64], heights: &[f64]) -> BarBuilder<'_>

Add a bar series and return a builder for customization.

pub fn histogram(&mut self, data: &[f64]) -> HistogramBuilder<'_>

Add a histogram series and return a builder for customization.

pub fn boxplot(&mut self, datasets: Vec<Vec<f64>>) -> BoxPlotBuilder<'_>

Add a box plot series and return a builder for customization.

pub fn heatmap(&mut self, data: Vec<Vec<f64>>) -> HeatmapBuilder<'_>

Add a heatmap series and return a builder for customization.

pub fn errorbar( &mut self, x: &[f64], y: &[f64], err: &[f64], ) -> ErrorBarBuilder<'_>

Add an error bar series and return a builder for customization.

pub fn add_series(&mut self, series: Box<dyn SeriesRenderer>) -> &mut Self

Add an arbitrary series.

Trait Implementations

impl Default for Axes

fn default() -> Axes

Returns the “default value” for a type.