Struct LinePlot 

pub struct LinePlot { /* private fields */ }

A structure representing a line plot.

The LinePlot struct facilitates the creation and customization of line plots with various options for data selection, layout configuration, and aesthetic adjustments. It supports the addition of multiple lines, customization of marker shapes, line styles, colors, opacity settings, and comprehensive layout customization including titles, axes, and legends.

Arguments

• data - A reference to the DataFrame containing the data to be plotted.
• x - A string slice specifying the column name to be used for the x-axis (independent variable).
• y - A string slice specifying the column name to be used for the y-axis (dependent variable).
• additional_lines - An optional vector of string slices specifying additional y-axis columns to be plotted as lines.
• size - An optional usize specifying the size of the markers or the thickness of the lines.
• color - An optional Rgb value specifying the color of the markers and lines. This is used when additional_lines is not specified.
• colors - An optional vector of Rgb values specifying the colors for the markers and lines. This is used when additional_lines is specified to differentiate between multiple lines.
• with_shape - An optional bool indicating whether to display markers with shapes on the plot.
• shape - An optional Shape specifying the shape of the markers.
• shapes - An optional vector of Shape values specifying multiple shapes for the markers when plotting multiple lines.
• width - An optional f64 specifying the width of the plotted lines.
• line - An optional Line specifying the type of the line (e.g., solid, dashed). This is used when additional_lines is not specified.
• lines - An optional vector of Line enums specifying the types of lines (e.g., solid, dashed) for each plotted line. This is used when additional_lines is specified to differentiate between multiple lines.
• plot_title - An optional Text struct specifying the title of the plot.
• x_title - An optional Text struct specifying the title of the x-axis.
• y_title - An optional Text struct specifying the title of the y-axis.
• legend_title - An optional Text struct specifying the title of the legend.
• x_axis - An optional reference to an Axis struct for customizing the x-axis.
• y_axis - An optional reference to an Axis struct for customizing the y-axis.
• legend - An optional reference to a Legend struct for customizing the legend of the plot (e.g., positioning, font, etc.).

Example

use ndarray::Array;

use polars::prelude::*;
use plotlars::{Axis, Line, LinePlot, Plot, Rgb, Text, TickDirection};

let x_values: Array<f64, _> = Array::linspace(0.0, 2.0 * std::f64::consts::PI, 1000);
let sine_values = x_values.mapv(f64::sin).to_vec();
let cosine_values = x_values.mapv(f64::cos).to_vec();
let x_values = x_values.to_vec();

let dataset = DataFrame::new(vec![
    Column::new("x".into(), x_values),
    Column::new("sine".into(), sine_values),
    Column::new("cosine".into(), cosine_values),
])
.unwrap();

LinePlot::builder()
    .data(&dataset)
    .x("x")
    .y("sine")
    .additional_lines(vec!["cosine"])
    .colors(vec![
        Rgb(255, 0, 0),
        Rgb(0, 255, 0),
    ])
    .lines(vec![Line::Solid, Line::Dot])
    .width(3.0)
    .with_shape(false)
    .plot_title(
        Text::from("Line Plot")
            .font("Arial")
            .size(18)
    )
    .legend_title(
        Text::from("series")
            .font("Arial")
            .size(15)
    )
    .x_axis(
       &Axis::new()
           .tick_direction(TickDirection::OutSide)
           .axis_position(0.5)
           .tick_values(vec![
               0.5 * std::f64::consts::PI,
               std::f64::consts::PI,
               1.5 * std::f64::consts::PI,
               2.0 * std::f64::consts::PI,
           ])
           .tick_labels(vec!["π/2", "π", "3π/2", "2π"])
    )
    .y_axis(
       &Axis::new()
           .tick_direction(TickDirection::OutSide)
           .tick_values(vec![-1.0, 0.0, 1.0])
           .tick_labels(vec!["-1", "0", "1"])
    )
    .build()
    .plot();

Implementations

impl LinePlot

pub fn builder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7, 'f8>() -> LinePlotBuilder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7, 'f8>

Examples found in repository

examples/lineplot.rs (line 16)

fn main() {
    let x_values = Array::linspace(0.0, 2.0 * std::f64::consts::PI, 1000).to_vec();

    let dataset = df![
        "x" => &x_values,
        "sine" => &x_values.iter().map(|arg0: &f64| f64::sin(*arg0)).collect::<Vec<_>>(),
        "cosine" => &x_values.iter().map(|arg0: &f64| f64::cos(*arg0)).collect::<Vec<_>>(),
    ]
    .unwrap();

    LinePlot::builder()
        .data(&dataset)
        .x("x")
        .y("sine")
        .additional_lines(vec!["cosine"])
        .colors(vec![Rgb(255, 0, 0), Rgb(0, 255, 0)])
        .lines(vec![Line::Solid, Line::Dot])
        .width(3.0)
        .with_shape(false)
        .plot_title(Text::from("Line Plot").font("Arial").size(18))
        .legend_title(Text::from("series").font("Arial").size(15))
        .x_axis(
            &Axis::new()
                .tick_direction(TickDirection::OutSide)
                .axis_position(0.5)
                .tick_values(vec![
                    0.5 * std::f64::consts::PI,
                    std::f64::consts::PI,
                    1.5 * std::f64::consts::PI,
                    2.0 * std::f64::consts::PI,
                ])
                .tick_labels(vec!["π/2", "π", "3π/2", "2π"]),
        )
        .y_axis(
            &Axis::new()
                .tick_direction(TickDirection::OutSide)
                .tick_values(vec![-1.0, 0.0, 1.0])
                .tick_labels(vec!["-1", "0", "1"]),
        )
        .build()
        .plot();
}

Trait Implementations

impl Clone for LinePlot

fn clone(&self) -> LinePlot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Serialize for LinePlot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.