Struct OptimizedDataFrame 

pub struct OptimizedDataFrame { /* private fields */ }

Optimized DataFrame implementation Uses columnar storage for high-speed data processing

Implementations

impl OptimizedDataFrame

pub fn new() -> Self

Create a new empty DataFrame

pub fn row_count(&self) -> usize

Get the number of rows in the DataFrame

pub fn column_count(&self) -> usize

Get the number of columns in the DataFrame

pub fn is_empty(&self) -> bool

Check if the DataFrame is empty

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

Get the column names

pub fn contains_column(&self, name: &str) -> bool

Check if a column exists

impl OptimizedDataFrame

pub fn from_csv<P: AsRef<Path>>(path: P, has_header: bool) -> Result<Self>

Create a DataFrame from a CSV file (high-performance implementation)

Arguments

• path - Path to the CSV file
• has_header - Whether the file has a header

Returns

• Result<Self> - DataFrame on success, error on failure

pub fn to_csv<P: AsRef<Path>>(&self, path: P, write_header: bool) -> Result<()>

Save DataFrame to a CSV file

Arguments

• path - Path to save the file
• write_header - Whether to write the header

Returns

• Result<()> - Ok on success, error on failure

pub fn from_json<P: AsRef<Path>>(path: P) -> Result<Self>

Read DataFrame from a JSON file

Arguments

• path - Path to the JSON file

Returns

• Result<Self> - DataFrame read from the file

pub fn to_json<P: AsRef<Path>>(&self, path: P, orient: JsonOrient) -> Result<()>

Write DataFrame to a JSON file

Arguments

• path - Path to the JSON file
• orient - JSON output format (Records or Columns)

Returns

• Result<()> - Ok on success

pub fn from_dataframe(df: &DataFrame) -> Result<Self>

Create a DataFrame from standard DataFrame (alias for from_standard_dataframe)

This is a public alias provided for backward compatibility with existing code

impl OptimizedDataFrame

pub fn add_column<C: Into<Column>>( &mut self, name: impl Into<String>, column: C, ) -> Result<()>

Add a column

pub fn add_int_column( &mut self, name: impl Into<String>, data: Vec<i64>, ) -> Result<()>

Add an integer column

pub fn add_float_column( &mut self, name: impl Into<String>, data: Vec<f64>, ) -> Result<()>

Add a floating-point column

pub fn add_string_column( &mut self, name: impl Into<String>, data: Vec<String>, ) -> Result<()>

Add a string column

pub fn add_boolean_column( &mut self, name: impl Into<String>, data: Vec<bool>, ) -> Result<()>

Add a boolean column

pub fn column(&self, name: &str) -> Result<ColumnView>

Get a reference to a column

pub fn column_type(&self, name: &str) -> Result<ColumnType>

Get the type of a column

pub fn remove_column(&mut self, name: &str) -> Result<Column>

Remove a column

pub fn rename_column( &mut self, old_name: &str, new_name: impl Into<String>, ) -> Result<()>

Rename a column

pub fn rename_columns( &mut self, column_map: &HashMap<String, String>, ) -> Result<()>

Rename columns in the DataFrame using a mapping

pub fn set_column_names(&mut self, names: Vec<String>) -> Result<()>

Set all column names in the DataFrame

pub fn get_value( &self, row_idx: usize, column_name: &str, ) -> Result<Option<String>>

Get the value at the specified row and column

pub fn get_index(&self) -> Option<&DataFrameIndex<String>>

Get the index

pub fn set_default_index(&mut self) -> Result<()>

Set the default index

pub fn set_index_directly( &mut self, index: DataFrameIndex<String>, ) -> Result<()>

Set the index directly

pub fn set_index_from_simple_index( &mut self, index: Index<String>, ) -> Result<()>

Set a simple index

pub fn reset_index(&mut self, name: &str, drop_index: bool) -> Result<()>

Add index as a column

pub fn set_index(&mut self, name: &str) -> Result<()>

Set column values as index

pub fn set_index_from_simple_index_internal( &mut self, index: Index<String>, ) -> Result<()>

👎Deprecated: This is an internal method that should not be used directly. Use set_index_from_simple_index instead.

Internal method to set string index directly (for conversion)

Arguments

• index - The index to set

Returns

• Result<()> - Ok on success, error on failure

pub fn select(&self, columns: &[&str]) -> Result<Self>

Select columns (as a new DataFrame)

pub fn get_string_column(&self, name: &str) -> Result<Vec<String>>

Get string column data

Arguments

• name - Column name

Returns

• Result<Vec<String>> - String data

pub fn get_float_column(&self, name: &str) -> Result<Vec<f64>>

Get float column data

Arguments

• name - Column name

Returns

• Result<Vec<f64>> - Float data

pub fn get_int_column(&self, name: &str) -> Result<Vec<Option<i64>>>

Get integer column data

Arguments

• name - Column name

Returns

• Result<Vec<Option<i64>>> - Integer data with nulls

pub fn len(&self) -> usize

Get the number of rows (alias for row_count)

impl OptimizedDataFrame

pub fn append(&self, other: &OptimizedDataFrame) -> Result<Self>

Append another DataFrame vertically Concatenate two DataFrames with compatible columns and create a new DataFrame

pub fn head(&self, n: usize) -> Result<Self>

Get the first n rows

pub fn tail(&self, n: usize) -> Result<Self>

Get the last n rows

pub fn sample(&self, n: usize, replace: bool, seed: Option<u64>) -> Result<Self>

Sample rows

pub fn get_row(&self, row_idx: usize) -> Result<Self>

Get a row using integer index (as a new DataFrame)

pub fn get_row_by_index(&self, key: &str) -> Result<Self>

Get a row by index

pub fn select_by_index<I, S>(&self, keys: I) -> Result<Self>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Select rows using index

pub fn filter(&self, condition_column: &str) -> Result<Self>

Filter (as a new DataFrame)

pub fn par_apply<F>(&self, func: F) -> Result<Self>

where F: Fn(&ColumnView) -> Result<Column> + Sync + Send,

Apply mapping function (with parallel processing support)

pub fn par_filter(&self, condition_column: &str) -> Result<Self>

Execute row filtering (automatically selects serial/parallel processing based on data size)

pub fn par_groupby( &self, group_by_columns: &[&str], ) -> Result<HashMap<String, Self>>

Execute groupby operation in parallel (optimized for data size)

pub fn inner_join( &self, other: &Self, left_on: &str, right_on: &str, ) -> Result<Self>

Inner join

pub fn left_join( &self, other: &Self, left_on: &str, right_on: &str, ) -> Result<Self>

Left join

pub fn right_join( &self, other: &Self, left_on: &str, right_on: &str, ) -> Result<Self>

Right join

pub fn outer_join( &self, other: &Self, left_on: &str, right_on: &str, ) -> Result<Self>

Outer join

pub fn apply<F>(&self, f: F, columns: Option<&[&str]>) -> Result<Self>

where F: Fn(&ColumnView) -> Result<Column> + Send + Sync,

Apply function to columns and return a new DataFrame with results (performance optimized version)

Arguments

• f - Function to apply (takes column view, returns new column)
• columns - Target column names (None means all columns)

Returns

• Result<Self> - DataFrame with processing results

pub fn applymap<F, G, H, I>( &self, column_name: &str, f_str: F, f_int: G, f_float: H, f_bool: I, ) -> Result<Self>

where F: Fn(&str) -> String + Send + Sync, G: Fn(&i64) -> i64 + Send + Sync, H: Fn(&f64) -> f64 + Send + Sync, I: Fn(&bool) -> bool + Send + Sync,

Apply function to each element (equivalent to applymap)

Arguments

• column_name - Target column name
• f - Function to apply (specific to column type)

Returns

• Result<Self> - DataFrame with processing results

pub fn melt( &self, id_vars: &[&str], value_vars: Option<&[&str]>, var_name: Option<&str>, value_name: Option<&str>, ) -> Result<Self>

Convert DataFrame to “long format” (melt operation)

Converts multiple columns into a single “variable” column and “value” column. This implementation prioritizes performance.

Arguments

• id_vars - Column names to keep unchanged (identifier columns)
• value_vars - Column names to convert (value columns). If not specified, all columns except id_vars
• var_name - Name for the variable column (default: “variable”)
• value_name - Name for the value column (default: “value”)

Returns

• Result<Self> - DataFrame converted to long format

pub fn sum(&self, column_name: &str) -> Result<f64>

Calculate the sum of a numeric column

pub fn mean(&self, column_name: &str) -> Result<f64>

Calculate the mean of a numeric column

pub fn max(&self, column_name: &str) -> Result<f64>

Calculate the maximum value of a numeric column

pub fn min(&self, column_name: &str) -> Result<f64>

Calculate the minimum value of a numeric column

pub fn count(&self, column_name: &str) -> Result<usize>

Count the number of elements in a column (excluding missing values)

pub fn aggregate( &self, column_names: &[&str], operation: &str, ) -> Result<HashMap<String, f64>>

Apply aggregation operation to multiple columns

pub fn sort_by(&self, by: &str, ascending: bool) -> Result<Self>

Sort DataFrame by the specified column

pub fn sort_by_columns( &self, by: &[&str], ascending: Option<&[bool]>, ) -> Result<Self>

Sort DataFrame by multiple columns

pub fn aggregate_numeric(&self, operation: &str) -> Result<HashMap<String, f64>>

Apply aggregation operation to all numeric columns

pub fn concat_rows(&self, other: &Self) -> Result<Self>

Concatenate rows from another DataFrame

This method adds the rows from another DataFrame to this one Both DataFrames must have the same column structure

pub fn sample_rows(&self, indices: &[usize]) -> Result<Self>

Sample rows by index

Arguments

• indices - Vector of row indices to include in the new DataFrame

Returns

A new DataFrame containing only the selected rows

impl OptimizedDataFrame

Direct aggregation methods for OptimizedDataFrame that eliminate conversion overhead

pub fn sum_direct(&self, column_name: &str) -> Result<f64>

Calculate the sum of a numeric column using direct operations

This method is 3-5x faster than the conversion-based approach by:

• Working directly on the target column
• Using optimized column methods with null handling
• Avoiding full DataFrame copying

pub fn mean_direct(&self, column_name: &str) -> Result<f64>

Calculate the mean of a numeric column using direct operations

pub fn max_direct(&self, column_name: &str) -> Result<f64>

Calculate the maximum value of a numeric column using direct operations

pub fn min_direct(&self, column_name: &str) -> Result<f64>

Calculate the minimum value of a numeric column using direct operations

pub fn count_direct(&self, column_name: &str) -> Result<usize>

Count the number of non-null elements in a column using direct access

pub fn sum_simd(&self, column_name: &str) -> Result<f64>

Calculate the sum of a numeric column using SIMD-accelerated direct operations

This method provides the best performance by combining:

• Direct column access (3-5x improvement over conversion)
• SIMD vectorization (2-4x additional improvement)
• Intelligent fallback for columns with null values

pub fn mean_simd(&self, column_name: &str) -> Result<f64>

Calculate the mean of a numeric column using SIMD-accelerated direct operations

pub fn max_simd(&self, column_name: &str) -> Result<f64>

Calculate the maximum value of a numeric column using SIMD-accelerated direct operations

pub fn min_simd(&self, column_name: &str) -> Result<f64>

Calculate the minimum value of a numeric column using SIMD-accelerated direct operations

Trait Implementations

impl Clone for OptimizedDataFrame

fn clone(&self) -> OptimizedDataFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DataFramePlotExt for OptimizedDataFrame

fn plot_column<P: AsRef<Path>>( &self, _column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Plot a column from this DataFrame with minimal configuration

fn line_plot<P: AsRef<Path>>( &self, _column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Create a line plot for a column

fn scatter_plot<P: AsRef<Path>>( &self, _column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Create a scatter plot for a column

fn bar_plot<P: AsRef<Path>>( &self, _column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Create a bar plot for a column

fn area_plot<P: AsRef<Path>>( &self, _column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Create an area plot for a column

fn box_plot<P: AsRef<Path>>( &self, _value_column: &str, _category_column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Create a box plot for a column grouped by a category

fn scatter_xy<P: AsRef<Path>>( &self, _x_column: &str, _y_column: &str, _path: P, _title: Option<&str>, ) -> Result<()>

Create a scatter plot between two columns

fn multi_line_plot<P: AsRef<Path>>( &self, _columns: &[&str], _path: P, _title: Option<&str>, ) -> Result<()>

Create a line plot for multiple columns

fn plot_svg<P: AsRef<Path>>( &self, _column: &str, _path: P, _plot_kind: PlotKind, _title: Option<&str>, ) -> Result<()>

Save the plot as SVG format

impl Debug for OptimizedDataFrame

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

Formats the value using the given formatter.

impl Default for OptimizedDataFrame

fn default() -> Self

Returns the “default value” for a type.