Struct Series 

pub struct Series { /* private fields */ }

A Series represents a single column of data with a name and dtype

Implementations

impl Series

pub fn new( name: impl Into<String>, data: ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Series

Create a new numeric series

Examples found in repository

examples/simple.rs (line 18)

fn main() {
    println!("=== StatOxide Simple Example ===\n");
    
    // 1. Create a DataFrame
    println!("1. Creating DataFrame:");
    let mut columns = HashMap::new();
    columns.insert("x".to_string(), Series::new("x", Array1::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0])));
    columns.insert("y".to_string(), Series::new("y", Array1::from_vec(vec![2.0, 4.0, 5.0, 4.0, 5.0])));
    
    let df = DataFrame::from_series(columns).unwrap();
    
    println!("   DataFrame shape: {} rows × {} columns", df.n_rows(), df.n_cols());
    println!("   Column names: {:?}\n", df.column_names());
    
    // 2. Parse a formula
    println!("2. Parsing formula:");
    let formula = Formula::parse("y ~ x").unwrap();
    println!("   Formula parsed successfully, variables: {:?}\n", formula.variables());
    
    // 3. Compute statistics
    println!("3. Computing statistics:");
    let x_view = df.column("x").unwrap().data();
    let y_view = df.column("y").unwrap().data();
    
    // Convert views to owned arrays
    let x_data = x_view.to_owned();
    let y_data = y_view.to_owned();
    
    let x_mean = mean(&x_data).unwrap();
    let x_std = std(&x_data, 1.0).unwrap();
    let corr = correlation(&x_data, &y_data).unwrap();
    
    println!("   Mean of x: {:.4}", x_mean);
    println!("   Std of x: {:.4}", x_std);
    println!("   Correlation(x, y): {:.4}\n", corr);
    
    // 4. Demonstrate module structure
    println!("4. Module structure available:");
    println!("   - statoxide::models::*  (GLM, linear regression, mixed effects)");
    println!("   - statoxide::stats::*   (statistical functions and tests)");
    println!("   - statoxide::tsa::*     (time series analysis)");
    println!("   - statoxide::linalg::*  (linear algebra)");
    println!("   - statoxide::utils::*   (utilities)\n");
    
    println!("=== StatOxide version {} ===", statoxide::version());
}

pub fn factor( name: impl Into<String>, levels: Vec<String>, indices: ArrayBase<OwnedRepr<usize>, Dim<[usize; 1]>>, ) -> Series

Create a factor/categorical series

pub fn name(&self) -> &str

Get series name

pub fn data(&self) -> ArrayBase<ViewRepr<&f64>, Dim<[usize; 1]>>

Get data as array view

Examples found in repository

examples/simple.rs (line 33)

fn main() {
    println!("=== StatOxide Simple Example ===\n");
    
    // 1. Create a DataFrame
    println!("1. Creating DataFrame:");
    let mut columns = HashMap::new();
    columns.insert("x".to_string(), Series::new("x", Array1::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0])));
    columns.insert("y".to_string(), Series::new("y", Array1::from_vec(vec![2.0, 4.0, 5.0, 4.0, 5.0])));
    
    let df = DataFrame::from_series(columns).unwrap();
    
    println!("   DataFrame shape: {} rows × {} columns", df.n_rows(), df.n_cols());
    println!("   Column names: {:?}\n", df.column_names());
    
    // 2. Parse a formula
    println!("2. Parsing formula:");
    let formula = Formula::parse("y ~ x").unwrap();
    println!("   Formula parsed successfully, variables: {:?}\n", formula.variables());
    
    // 3. Compute statistics
    println!("3. Computing statistics:");
    let x_view = df.column("x").unwrap().data();
    let y_view = df.column("y").unwrap().data();
    
    // Convert views to owned arrays
    let x_data = x_view.to_owned();
    let y_data = y_view.to_owned();
    
    let x_mean = mean(&x_data).unwrap();
    let x_std = std(&x_data, 1.0).unwrap();
    let corr = correlation(&x_data, &y_data).unwrap();
    
    println!("   Mean of x: {:.4}", x_mean);
    println!("   Std of x: {:.4}", x_std);
    println!("   Correlation(x, y): {:.4}\n", corr);
    
    // 4. Demonstrate module structure
    println!("4. Module structure available:");
    println!("   - statoxide::models::*  (GLM, linear regression, mixed effects)");
    println!("   - statoxide::stats::*   (statistical functions and tests)");
    println!("   - statoxide::tsa::*     (time series analysis)");
    println!("   - statoxide::linalg::*  (linear algebra)");
    println!("   - statoxide::utils::*   (utilities)\n");
    
    println!("=== StatOxide version {} ===", statoxide::version());
}

pub fn len(&self) -> usize

Get length of series

pub fn is_empty(&self) -> bool

Check if series is empty

pub fn mean(&self) -> Option<f64>

Compute mean

pub fn var(&self, ddof: f64) -> Option<f64>

Compute variance

pub fn std(&self, ddof: f64) -> Option<f64>

Compute standard deviation

pub fn min(&self) -> Option<f64>

Compute minimum value

pub fn max(&self) -> Option<f64>

Compute maximum value

pub fn quantile(&self, q: f64) -> Option<f64>

Compute quantile using R’s type 7 method

pub fn map(&self, f: impl Fn(f64) -> f64) -> Series

Apply a function element-wise

pub fn standardize(&self) -> Option<Series>

Standardize (z-score normalization)

Trait Implementations

impl Clone for Series

fn clone(&self) -> Series

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Series

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Series

fn deserialize<__D>( __deserializer: __D, ) -> Result<Series, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Series

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

where __S: Serializer,

Serialize this value into the given Serde serializer.