Struct DataFrame 

pub struct DataFrame {
    pub data: Vec<Series>,
    pub ics: Vec<String>,
}

Generic DataFrame structure

Example

extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    // 1. Series to DataFrame
    // 1-1. Declare Series
    let a = Series::new(vec![1, 2, 3, 4]);
    let b = Series::new(vec![true, false, false, true]);
    let c = Series::new(vec![0.1, 0.2, 0.3, 0.4]);

    // 1-2. Declare DataFrame (default header: 0, 1, 2)
    let mut df = DataFrame::new(vec![a, b, c]);
    df.set_header(vec!["a", "b", "c"]);
    df.print(); // Pretty print for DataFrame

    // 2. Empty DataFrame
    let mut dg = DataFrame::new(vec![]);
    dg.push("a", Series::new(vec![1,2,3,4]));
    dg.push("b", Series::new(vec![true, false, false, true]));
    dg.push("c", Series::new(vec![0.1, 0.2, 0.3, 0.4]));
    dg.print();

    assert_eq!(df, dg);
}

Fields

data: Vec<Series>

ics: Vec<String>

Implementations

impl DataFrame

pub fn new(v: Vec<Series>) -> Self

Declare new DataFrame with Vec<Series>

pub fn header(&self) -> &Vec<String>

pub fn header_mut(&mut self) -> &mut Vec<String>

pub fn set_header(&mut self, new_header: Vec<&str>)

Change header

pub fn push(&mut self, name: &str, series: Series)

Push new pair of head, Series to DataFrame

pub fn row(&self, i: usize) -> DataFrame

Extract specific row as DataFrame

pub fn spread(&self) -> String

pub fn as_types(&mut self, dtypes: Vec<DType>)

Type casting for DataFrame

Examples

extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = Series::new(vec![1i32, 2, 3, 4]);
    let b = Series::new(vec![true, false, false, true]);
     
    let mut df = DataFrame::new(vec![a, b]);    // I32, Bool
    df.as_types(vec![USIZE, U8]);               // USIZE, U8

    let c = Series::new(vec![1usize, 2, 3, 4]);
    let d = Series::new(vec![1u8, 0, 0, 1]);
    let dg = DataFrame::new(vec![c, d]);

    assert_eq!(df, dg);
}

pub fn drop(&mut self, col_header: &str)

Drop specific column by header

Examples

extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = Series::new(vec![1,2,3,4]);
    let b = Series::new(vec![5,6,7,8]);

    let mut df = DataFrame::new(vec![a.clone(), b]);
    df.set_header(vec!["a", "b"]);

    let mut dg = DataFrame::new(vec![a]);
    dg.set_header(vec!["a"]);

    df.drop("b");

    assert_eq!(df, dg);
}

pub fn filter_by<F>(&self, column: &str, predicate: F) -> Result<DataFrame>

where F: Fn(Scalar) -> bool,

Filter DataFrame by specific column

pub fn mask(&self, mask: &Series) -> Result<DataFrame>

Mask DataFrame with a boolean Series

pub fn select_rows(&self, indices: &[usize]) -> DataFrame

Select rows based on indices

pub fn nrow(&self) -> usize

Number of rows (max column length)

pub fn ncol(&self) -> usize

Number of columns

pub fn shape(&self) -> (usize, usize)

Shape as (nrow, ncol)

pub fn dtypes(&self) -> Vec<DType>

DType of each column

pub fn is_empty(&self) -> bool

Check if the DataFrame has no columns or no rows

pub fn contains(&self, col_header: &str) -> bool

Check if the DataFrame contains a column with the given header

pub fn head(&self, n: usize) -> DataFrame

Return the first n rows

pub fn tail(&self, n: usize) -> DataFrame

Return the last n rows

pub fn slice(&self, offset: usize, length: usize) -> DataFrame

Return a slice of rows starting at offset with the given length

pub fn select(&self, columns: &[&str]) -> DataFrame

Select specific columns by name, returning a new DataFrame

Panics if any column name does not exist.

pub fn rename(&mut self, old: &str, new: &str)

Rename a column in-place

Panics if the old column name does not exist.

pub fn column_names(&self) -> Vec<&str>

Return column names as Vec<&str>

pub fn select_dtypes(&self, dtypes: &[DType]) -> DataFrame

Select columns whose dtype is in the given list

pub fn describe(&self) -> DataFrame

Compute descriptive statistics for numeric columns

Returns a DataFrame with rows: count, mean, sd, min, max and one column per numeric column from the original DataFrame.

pub fn sum(&self) -> DataFrame

Sum of each numeric column as a single-row DataFrame

pub fn mean(&self) -> DataFrame

Mean of each numeric column as a single-row DataFrame

Trait Implementations

impl Clone for DataFrame

fn clone(&self) -> DataFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataFrame

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

Formats the value using the given formatter.

impl Display for DataFrame

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

Formats the value using the given formatter.

impl Index<&str> for DataFrame

type Output = Series

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for DataFrame

type Output = Series

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<&str> for DataFrame

fn index_mut(&mut self, index: &str) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<usize> for DataFrame

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq for DataFrame

fn eq(&self, other: &DataFrame) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Printable for DataFrame

fn print(&self)

impl SimpleParquet for DataFrame

Available on crate feature parquet only.

fn write_parquet(&self, path: &str) -> Result<(), Box<dyn Error>>

fn read_parquet(path: &str) -> Result<Self, Box<dyn Error>>

impl WithCSV for DataFrame

Available on crate feature csv only.

fn write_csv(&self, file_path: &str) -> Result<(), Box<dyn Error>>

Write csv file

fn read_csv(file_path: &str, delimiter: char) -> Result<Self, Box<dyn Error>>

Read csv file with delimiter

impl WithNetCDF for DataFrame

Available on crate feature nc only.

fn write_nc(&self, file_path: &str) -> Result<(), Box<dyn Error>>

write netcdf file

fn read_nc(file_path: &str) -> Result<Self, Box<dyn Error>>

Read netcdf to DataFrame

fn read_nc_by_header( file_path: &str, header: Vec<&str>, ) -> Result<Self, Box<dyn Error>>

Read netcdf to DataFrame with specific header

Example

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() -> Result<(), Box<dyn Error>> {
    let mut df = DataFrame::new(vec![]);
    df.push("a", Series::new(vec![1,2,3,4]));
    df.push("b", Series::new(vec!['a', 'b', 'c', 'd']));
    df.push("c", Series::new(c!(0.1, 0.2, 0.3, 0.4)));
    df.write_nc("example_data/doc_nc2.nc")?;

    let dg = DataFrame::read_nc_by_header("example_data/doc_nc2.nc", vec!["a", "c"])?;

    df.drop("b");

    assert_eq!(df, dg);
     
    Ok(())
}

impl WithParquet for DataFrame

Available on crate feature parquet only.

fn write_parquet( &self, file_path: &str, compression: Compression, ) -> Result<(), Box<dyn Error>>

Write DataFrame to parquet

fn read_parquet(file_path: &str) -> Result<Self, Box<dyn Error>>

where Self: Sized,

Read parquet to DataFrame

impl StructuralPartialEq for DataFrame