//! Pandas-like dataframe & series.

//!

//! ## Series

//!

//! ### 1. Declare Series

//!

//! * To declare series, you should have `Vec<T>` where `T` is one of following types.

//!

//! | Primitive type | DType |

//! | :-----: | :-----: |

//! | `usize` | `USIZE` |

//! | `u8` | `U8` |

//! | `u16` | `U16` |

//! | `u32` | `U32` |

//! | `u64` | `U64` |

//! | `isize` | `ISIZE` |

//! | `i8` | `I8` |

//! | `i16` | `I16` |

//! | `i32` | `I32` |

//! | `i64` | `I64` |

//! | `f32` | `F32` |

//! | `f64` | `F64` |

//! | `bool` | `Bool` |

//! | `char` | `Char` |

//! | `String` | `Str` |

//!

//! * If you prepare `Vec<T>`, then `Series::new(Vec<T>)`

//!

//! ### 2. Methods for Series

//!

//! * `TypedVector<T> trait for Series`

//!

//! ```ignore

//! pub trait TypedVector<T> {

//! fn new(v: Vec<T>) -> Self;

//! fn to_vec(&self) -> Vec<T>;

//! fn as_slice(&self) -> &[T];

//! fn as_slice_mut(&mut self) -> &mut [T];

//! fn at_raw(&self, i: usize) -> T;

//! fn push(&mut self, elem: T);

//! }

//! ```

//!

//! * `Series` methods

//!

//! ```ignore

//! impl Series {

//! pub fn at(&self, i: usize) -> Scalar;

//! pub fn len(&self) -> usize;

//! pub fn to_type(&self, dtype: DType) -> Series;

//! pub fn as_type(&mut self, dtype: DType);

//! }

//! ```

//!

//! * `at` is simple getter for `Series`. It returns `Scalar`.

//! * `as_type` is a method for mutable type casting.

//! * All types can be changed to `Str`.

//! * All integer & float types can be exchanged.

//! * `Bool, Char` can be changed to `Str` or `U8` only.

//! * `U8` can be changed to all types.

//!

//! ### 3. Example

//!

//! ```rust

//! extern crate peroxide;

//! use peroxide::fuga::*;

//!

//! fn main() {

//! let a = Series::new(vec![1, 2, 3, 4]);

//! let b = Series::new(vec!['a', 'b', 'c', 'd']);

//! let mut c = Series::new(vec![true, false, false, true]);

//!

//! a.print(); // print for Series

//! b.dtype.print(); // print for dtype of Series (=Char)

//! c.as_type(U8); // Bool => U8

//!

//! assert_eq!(c.dtype, U8);

//! }

//! ```

//!

//! ## DataFrame

//!

//! ### 1. Declare DataFrame

//!

//! * To declare dataframe, use constructor.

//! * `DataFrame::new(Vec<Series>)`

//!

//! ```rust

//! extern crate peroxide;

//! use peroxide::fuga::*;

//!

//! fn main() {

//! // 1-1. Empty DataFrame

//! let mut df = DataFrame::new(vec![]);

//!

//! // 1-2. Push Series

//! df.push("a", Series::new(vec![1, 2, 3, 4]));

//! df.push("b", Series::new(vec![0.1, 0.2, 0.3, 0.4]));

//! df.push("c", Series::new(vec!['a', 'b', 'c', 'd']));

//!

//! // 1-3. Print

//! df.print();

//!

//! // 2-1. Construct Series first

//! let a = Series::new(vec![1, 2, 3, 4]);

//! let b = Series::new(vec![0.1, 0.2, 0.3, 0.4]);

//! let c = Series::new(vec!['a', 'b', 'c', 'd']);

//!

//! // 2-2. Declare DataFrame with exist Series

//! let mut dg = DataFrame::new(vec![a, b, c]);

//!

//! // 2-3. Print or Set header

//! dg.print(); // But header: 0 1 2

//! dg.set_header(vec!["a", "b", "c"]); // Change header

//! }

//! ```

//!

//! ### 2. Methods for DataFrame

//!

//! * `DataFrame` method

//!

//! ```ignore

//! impl DataFrame {

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

//! 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>);

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

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

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

//! pub fn spread(&self) -> String;

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

//! }

//! ```

//!

//! * `push(&mut self, name: &str, series: Series)`: push head & Series pair

//! * `drop(&mut self, col_header: &str)`: drop specific column by header

//! * `row(&self, i: usize) -> DataFrame` : Extract $i$-th row as new DataFrame

//!

//! * `WithCSV` trait

//!

//! ```ignore

//! pub trait WithCSV: Sized {

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

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

//! }

//! ```

//!

//! * `csv` feature should be required

//!

//! ```rust

//! // Example for CSV

//! #[macro_use]

//! extern crate peroxide;

//! use peroxide::fuga::*;

//!

//! fn main() -> Result<(), Box<dyn Error>> {

//! # #[cfg(feature="csv")]

//! # {

//! // Write CSV

//! let mut df = DataFrame::new(vec![]);

//! df.push("a", Series::new(vec!['x', 'y', 'z']));

//! df.push("b", Series::new(vec![0, 1, 2]));

//! df.push("c", Series::new(c!(0.1, 0.2, 0.3)));

//! df.write_csv("example_data/doc_csv.csv")?;

//!

//! // Read CSV

//! let mut dg = DataFrame::read_csv("example_data/doc_csv.csv", ',')?;

//! dg.as_types(vec![Char, I32, F64]);

//!

//! assert_eq!(df, dg);

//! # }

//!

//! Ok(())

//! }

//! ```

//!

//! * `WithNetCDF` trait

//!

//! ```ignore

//! pub trait WithNetCDF: Sized {

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

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

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

//! }

//! ```

//!

//! * `nc` feature should be required

//! * `libnetcdf` dependency should be required

//! * `Char`, `Bool` are saved as `U8` type. Thus, for reading `Char` or `Bool` type nc file,

//! explicit type casting is required.

//!

//! ```

//! #[macro_use]

//! extern crate peroxide;

//! use peroxide::fuga::*;

//!

//! fn main() -> Result<(), Box<dyn Error>> {

//! # #[cfg(feature = "nc")]

//! # {

//! // Write netcdf

//! let mut df = DataFrame::new(vec![]);

//! df.push("a", Series::new(vec!['x', 'y', 'z']));

//! df.push("b", Series::new(vec![0, 1, 2]));

//! df.push("c", Series::new(c!(0.1, 0.2, 0.3)));

//! df.write_nc("example_data/doc_nc.nc")?;

//!

//! // Read netcdf

//! let mut dg = DataFrame::read_nc("example_data/doc_nc.nc")?;

//! dg["a"].as_type(Char); // Char, Bool are only read/written as U8 type

//!

//! assert_eq!(df, dg);

//! # }

//!

//! Ok(())

//! }

//! ```

//!

//! * `WithParquet` trait

//!

//! ```ignore

//! pub trait WithParquet: Sized {

//! fn write_parquet(&self, file_path: &str, compression: CompressionOptions) -> Result<(), Box<dyn Error>>;

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

//! }

//! ```

//!

//! * `parquet` feature should be required

//! * `Char` is saved with `String` type. Thus, for reading `Char` type parquet file,

//! the output type is `String`.

//! * **Caution** : For different length `Bool` type column, missing values are filled with `false`.

//! ```

//! #[macro_use]

//! extern crate peroxide;

//! use peroxide::fuga::*;

//!

//! fn main() -> Result<(), Box<dyn Error>> {

//! # #[cfg(feature = "parquet")]

//! # {

//! // Write parquet

//! let mut df = DataFrame::new(vec![]);

//! df.push("a", Series::new(vec!['x', 'y', 'z']));

//! df.push("b", Series::new(vec![0, 1, 2]));

//! df.push("c", Series::new(c!(0.1, 0.2, 0.3)));

//! df.write_parquet("example_data/doc_pq.parquet", CompressionOptions::Uncompressed)?;

//!

//! // Read parquet

//! let mut dg = DataFrame::read_parquet("example_data/doc_pq.parquet")?;

//! dg["a"].as_type(Char); // Char is only read/written as String type

//!

//! assert_eq!(df, dg);

//! # }

//!

//! Ok(())

//! }

//! ```

#[cfg(feature="csv")]

use std::collections::HashMap;

use std::fmt;

use std::ops::{Index, IndexMut};

use std::cmp::{max, min};

#[cfg(any(feature="csv", feature="nc", feature="parquet"))]

use std::error::Error;

use crate::util::{

useful::tab,

print::LowerExpWithPlus,

};

use crate::traits::math::Vector;

use DType::{

USIZE,U8,U16,U32,U64,

ISIZE,I8,I16,I32,I64,

F32,F64,Bool,Char,Str

};

#[cfg(feature="csv")]

use csv::{ReaderBuilder, WriterBuilder};

#[cfg(feature="nc")]

use netcdf::{

types::VariableType,

variable::{VariableMut, Variable},

Numeric,

};

#[cfg(feature="parquet")]

use arrow2::{

array::{

PrimitiveArray,

BooleanArray,

Utf8Array,

Array

},

chunk::Chunk,

datatypes::{Field, DataType, Schema},

types::NativeType,

io::parquet::write::{

WriteOptions,

CompressionOptions,

RowGroupIterator,

Version,

FileWriter,

Encoding

},

io::parquet::read::{

read_metadata,

infer_schema,

FileReader,

}

};

// =============================================================================

// Enums

// =============================================================================

/// Data Type enum

#[derive(Debug, Copy, Clone, Eq, PartialEq)]

pub enum DType {

}

/// Vector with `DType`

#[derive(Debug, Clone, PartialEq)]

pub enum DTypeArray {

}

/// Scalar with `DType`

#[derive(Debug, Clone, PartialEq, PartialOrd)]

pub enum DTypeValue {

}

// =============================================================================

// Structs

// =============================================================================

/// Generic `DataFrame` structure

///

/// # Example

///

/// ```rust

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

/// }

/// ```

#[derive(Debug, Clone, PartialEq)]

pub struct DataFrame {

pub data: Vec<Series>,

pub ics: Vec<String>,

}

/// Generic Series

///

/// # Example

///

/// ```rust

/// extern crate peroxide;

/// use peroxide::fuga::*;

///

/// fn main() {

/// // Declare Series with Vec<T> (T: primitive type)

/// let a = Series::new(vec![1i32, 2, 3, 4]);

/// a.print(); // print for Series

/// a.dtype.print(); // print for dtype of Series

///

/// let b: &[i32] = a.as_slice(); // Borrow series to &[T]

/// let c: Vec<i32> = a.to_vec(); // Series to Vec<T> (clone)

///

/// // ...

/// }

/// ```

#[derive(Debug, Clone, PartialEq)]

pub struct Series {

pub values: DTypeArray,

pub dtype: DType,

}

/// Generic Scalar

#[derive(Debug, Clone, PartialEq)]

pub struct Scalar {

pub value: DTypeValue,

pub dtype: DType,

}

// =============================================================================

// Traits

// =============================================================================

pub trait TypedScalar<T> {

fn new(s: T) -> Self where Self: Sized;

fn unwrap(self) -> T;

}

pub trait TypedVector<T> {

}

// =============================================================================

// Macros & Private functions

// =============================================================================

macro_rules! impl_typed_scalar {

}

macro_rules! impl_typed_vector {

}

macro_rules! dtype_case {

}

macro_rules! dtype_match {

}

macro_rules! set_space {

}

macro_rules! format_float_vec {

}

/// ty1 -> ty2

macro_rules! type_cast_vec {

}

macro_rules! string_cast_vec {

}

macro_rules! type_parse_vec {

}

macro_rules! dtype_parse_vec_part {

}

macro_rules! dtype_cast_vec_part {

}

macro_rules! dtype_cast_vec {

}

fn len<T>(x: Vec<T>) -> usize {

x.len()

}

fn to_string<T: fmt::Display>(x: T) -> String {

x.to_string()

}

#[cfg(feature= "nc")]

fn dtype_to_vtype(dt: DType) -> netcdf::types::BasicType {

}

#[cfg(feature= "nc")]

fn vtype_to_dtype(dv: netcdf::types::BasicType) -> DType {

}

#[cfg(feature= "nc")]

fn nc_put_value<T: Numeric>(var: &mut VariableMut, v: Vec<T>) -> Result<(), netcdf::error::Error> {

var.put_values(&v, None, None)

}

#[cfg(feature= "nc")]

fn nc_read_value<T: Numeric + Default + Clone>(val: &Variable, v: Vec<T>) -> Result<Series, netcdf::error::Error> where Series: TypedVector<T> {

}

#[cfg(feature="parquet")]

fn dtype_to_arrow(dt: DType) -> DataType {

}

#[cfg(feature="parquet")]

fn arrow_to_dtype(dt: DataType) -> DType {

}

#[cfg(feature="parquet")]

macro_rules! dtype_case_to_arrow {

}

#[cfg(feature="parquet")]

macro_rules! dtype_match_to_arrow {