Struct peroxide::structure::dataframe::Series

pub struct Series {
    pub values: DTypeArray,
    pub dtype: DType,
}

Generic Series

Example

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)
     
    // ...
}

Fields

values: DTypeArray

dtype: DType

Implementations

impl Series

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

Getter for Series

Examples

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

fn main() {
    let a = Series::new(vec![1i32,2,3,4]);
    let x = a.at(0);

    assert_eq!(x, Scalar::new(1i32));
}

pub fn len(&self) -> usize

Length for Series

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

Explicit type casting for Series

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

Type casting for Series

Examples

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

fn main() {
    let mut a = Series::new(vec![1i32, 2, 3, 4]);
    a.as_type(USIZE);
     
    assert_eq!(a, Series::new(vec![1usize, 2, 3, 4]));
}

Trait Implementations

impl Clone for Series

pub fn clone(&self) -> Series

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Series

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

Formats the value using the given formatter.

impl PartialEq<Series> for Series

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Printable for Series

pub fn print(&self)

impl StructuralPartialEq for Series

impl TypedVector<String> for Series

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

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

pub fn as_slice(&self) -> &[String]

pub fn as_slice_mut(&mut self) -> &mut [String]

pub fn at_raw(&self, i: usize) -> String

pub fn push(&mut self, elem: String)

pub fn map<F: Fn(String) -> String>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut String)>(&mut self, f: F)

impl TypedVector<bool> for Series

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

pub fn to_vec(&self) -> Vec<bool>

pub fn as_slice(&self) -> &[bool]

pub fn as_slice_mut(&mut self) -> &mut [bool]

pub fn at_raw(&self, i: usize) -> bool

pub fn push(&mut self, elem: bool)

pub fn map<F: Fn(bool) -> bool>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut bool)>(&mut self, f: F)

impl TypedVector<char> for Series

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

pub fn to_vec(&self) -> Vec<char>

pub fn as_slice(&self) -> &[char]

pub fn as_slice_mut(&mut self) -> &mut [char]

pub fn at_raw(&self, i: usize) -> char

pub fn push(&mut self, elem: char)

pub fn map<F: Fn(char) -> char>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut char)>(&mut self, f: F)

impl TypedVector<f32> for Series

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

pub fn to_vec(&self) -> Vec<f32>

pub fn as_slice(&self) -> &[f32]

pub fn as_slice_mut(&mut self) -> &mut [f32]

pub fn at_raw(&self, i: usize) -> f32

pub fn push(&mut self, elem: f32)

pub fn map<F: Fn(f32) -> f32>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut f32)>(&mut self, f: F)

impl TypedVector<f64> for Series

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

pub fn to_vec(&self) -> Vec<f64>

pub fn as_slice(&self) -> &[f64]

pub fn as_slice_mut(&mut self) -> &mut [f64]

pub fn at_raw(&self, i: usize) -> f64

pub fn push(&mut self, elem: f64)

pub fn map<F: Fn(f64) -> f64>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut f64)>(&mut self, f: F)

impl TypedVector<i16> for Series

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

pub fn to_vec(&self) -> Vec<i16>

pub fn as_slice(&self) -> &[i16]

pub fn as_slice_mut(&mut self) -> &mut [i16]

pub fn at_raw(&self, i: usize) -> i16

pub fn push(&mut self, elem: i16)

pub fn map<F: Fn(i16) -> i16>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut i16)>(&mut self, f: F)

impl TypedVector<i32> for Series

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

pub fn to_vec(&self) -> Vec<i32>

pub fn as_slice(&self) -> &[i32]

pub fn as_slice_mut(&mut self) -> &mut [i32]

pub fn at_raw(&self, i: usize) -> i32

pub fn push(&mut self, elem: i32)

pub fn map<F: Fn(i32) -> i32>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut i32)>(&mut self, f: F)

impl TypedVector<i64> for Series

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

pub fn to_vec(&self) -> Vec<i64>

pub fn as_slice(&self) -> &[i64]

pub fn as_slice_mut(&mut self) -> &mut [i64]

pub fn at_raw(&self, i: usize) -> i64

pub fn push(&mut self, elem: i64)

pub fn map<F: Fn(i64) -> i64>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut i64)>(&mut self, f: F)

impl TypedVector<i8> for Series

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

pub fn to_vec(&self) -> Vec<i8>

pub fn as_slice(&self) -> &[i8]

pub fn as_slice_mut(&mut self) -> &mut [i8]

pub fn at_raw(&self, i: usize) -> i8

pub fn push(&mut self, elem: i8)

pub fn map<F: Fn(i8) -> i8>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut i8)>(&mut self, f: F)

impl TypedVector<isize> for Series

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

pub fn to_vec(&self) -> Vec<isize>

pub fn as_slice(&self) -> &[isize]

pub fn as_slice_mut(&mut self) -> &mut [isize]

pub fn at_raw(&self, i: usize) -> isize

pub fn push(&mut self, elem: isize)

pub fn map<F: Fn(isize) -> isize>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut isize)>(&mut self, f: F)

impl TypedVector<u16> for Series

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

pub fn to_vec(&self) -> Vec<u16>

pub fn as_slice(&self) -> &[u16]

pub fn as_slice_mut(&mut self) -> &mut [u16]

pub fn at_raw(&self, i: usize) -> u16

pub fn push(&mut self, elem: u16)

pub fn map<F: Fn(u16) -> u16>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut u16)>(&mut self, f: F)

impl TypedVector<u32> for Series

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

pub fn to_vec(&self) -> Vec<u32>

pub fn as_slice(&self) -> &[u32]

pub fn as_slice_mut(&mut self) -> &mut [u32]

pub fn at_raw(&self, i: usize) -> u32

pub fn push(&mut self, elem: u32)

pub fn map<F: Fn(u32) -> u32>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut u32)>(&mut self, f: F)

impl TypedVector<u64> for Series

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

pub fn to_vec(&self) -> Vec<u64>

pub fn as_slice(&self) -> &[u64]

pub fn as_slice_mut(&mut self) -> &mut [u64]

pub fn at_raw(&self, i: usize) -> u64

pub fn push(&mut self, elem: u64)

pub fn map<F: Fn(u64) -> u64>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut u64)>(&mut self, f: F)

impl TypedVector<u8> for Series

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

pub fn to_vec(&self) -> Vec<u8>

pub fn as_slice(&self) -> &[u8]

pub fn as_slice_mut(&mut self) -> &mut [u8]

pub fn at_raw(&self, i: usize) -> u8

pub fn push(&mut self, elem: u8)

pub fn map<F: Fn(u8) -> u8>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut u8)>(&mut self, f: F)

impl TypedVector<usize> for Series

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

pub fn to_vec(&self) -> Vec<usize>

pub fn as_slice(&self) -> &[usize]

pub fn as_slice_mut(&mut self) -> &mut [usize]

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

pub fn push(&mut self, elem: usize)

pub fn map<F: Fn(usize) -> usize>(&self, f: F) -> Self

pub fn mut_map<F: Fn(&mut usize)>(&mut self, f: F)

impl Vector for Series

pub fn add_vec<'a, 'b>(&'a self, rhs: &'b Self) -> Self

Add series

Example

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

fn main() {
    let a = Series::new(vec![1,2,3]);
    let b = Series::new(vec![3,2,1]);
    let c = a.add_vec(&b);
    assert_eq!(c, Series::new(vec![4,4,4]));
}

pub fn sub_vec<'a, 'b>(&'a self, rhs: &'b Self) -> Self

Sub series

Example

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

fn main() {
    let a = Series::new(vec![4,5,6]);
    let b = Series::new(vec![1,2,3]);
    let c = a.sub_vec(&b);
    assert_eq!(c, Series::new(vec![3,3,3]));
}

pub fn mul_scalar<T: Into<f64>>(&self, rhs: T) -> Self

Mul Scalar

Example

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

fn main() {
    let a = Series::new(vec![1,2,3]);
    let b = 2;
    let c = a.mul_scalar(b);
    assert_eq!(c, Series::new(vec![2,4,6]));
}