Struct NumericTable 

pub struct NumericTable { /* private fields */ }

A table whose cells have all been validated as numeric (RFC-034 §4.4).

Produced by Table::try_numeric. Holds row-major f64 data ready to become a matten::Tensor via NumericTable::to_tensor.

Implementations

impl NumericTable

pub fn row_count(&self) -> usize

Number of rows.

pub fn column_count(&self) -> usize

Number of columns.

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

Column names, in column order.

pub fn to_tensor(&self) -> Result<Tensor, MattenDataError>

Build a numeric matten::Tensor with shape [rows, columns], row-major.

Errors with MattenDataError::EmptySelection if there are no columns, and wraps any core construction failure (for example a zero-length dimension when there are no rows) as MattenDataError::Matten.

Examples found in repository

examples/data_00_quickstart.rs (line 32)

fn main() -> Result<(), matten_data::MattenDataError> {
    // A small table with one text column and one missing numeric cell.
    let csv = "\
region,sales,cost
north,100,40
south,150,
east,120,55";

    let tensor = Table::from_csv_str(csv)?
        .select_columns(["sales", "cost"])? // keep only the numeric columns
        .fill_missing(0.0)? // the missing south/cost becomes 0.0, explicitly
        .try_numeric()? // strict, explicit conversion to f64
        .to_tensor()?; // a normal [rows, columns] Tensor

    println!("shape: {:?}", tensor.shape());
    println!("data : {:?}", tensor.as_slice());

    assert_eq!(tensor.shape(), &[3, 2]);
    assert_eq!(tensor.as_slice(), &[100.0, 40.0, 150.0, 0.0, 120.0, 55.0]);

    println!("data_00_quickstart: OK");
    Ok(())
}

examples/csv_to_tensor.rs (line 38)

fn main() -> Result<(), matten_data::MattenDataError> {
    // A small, messy table: a text column and one missing numeric cell.
    let csv = "\
region,sales,cost,quantity
north,100,40,5
south,150,,7
east,120,55,6";

    let table = Table::from_csv_str(csv)?;

    // Inspect what we have before converting anything.
    println!("{}", table.schema_summary());

    // Select only the numeric columns we want, fill the one missing cost with 0,
    // convert explicitly, and produce a [rows, columns] f64 tensor.
    let tensor = table
        .select_columns(["sales", "cost", "quantity"])?
        .fill_missing(0.0)?
        .try_numeric()?
        .to_tensor()?;

    println!("tensor shape: {:?}", tensor.shape());
    println!("tensor data : {:?}", tensor.as_slice());

    // 3 rows x 3 columns; the missing south/cost became 0.0.
    assert_eq!(tensor.shape(), &[3, 3]);
    assert_eq!(
        tensor.as_slice(),
        &[100.0, 40.0, 5.0, 150.0, 0.0, 7.0, 120.0, 55.0, 6.0]
    );
    println!("csv_to_tensor: OK");
    Ok(())
}

examples/data_04_to_tensor.rs (line 29)

fn main() -> Result<(), matten_data::MattenDataError> {
    let csv = "\
region,sales,cost
north,100,40
south,150,45
east,120,55";

    let tensor: Tensor = Table::from_csv_str(csv)?
        .select_columns(["sales", "cost"])?
        .try_numeric()?
        .to_tensor()?;

    // [rows, columns] = [3, 2].
    assert_eq!(tensor.shape(), &[3, 2]);

    // Row-major: [north.sales, north.cost, south.sales, south.cost, ...].
    assert_eq!(tensor.as_slice(), &[100.0, 40.0, 150.0, 45.0, 120.0, 55.0]);

    // It is a plain Tensor, so core `matten` operations apply. Mean over axis 0
    // (down the rows) gives the per-column mean: [mean(sales), mean(cost)].
    let column_means = tensor.mean_axis(0);
    println!("shape        : {:?}", tensor.shape());
    println!("column means : {:?}", column_means.as_slice());

    assert_eq!(column_means.shape(), &[2]);
    assert_eq!(
        column_means.as_slice(),
        &[(100.0 + 150.0 + 120.0) / 3.0, (40.0 + 45.0 + 55.0) / 3.0]
    );

    println!("data_04_to_tensor: OK");
    Ok(())
}

examples/data_03_missing_values.rs (line 38)

fn main() -> Result<(), MattenDataError> {
    let csv = "\
region,sales,cost
north,100,40
south,150,
east,120,55";

    let table = Table::from_csv_str(csv)?;
    let numeric_cols = table.select_columns(["sales", "cost"])?;

    // Converting with a missing cell still present is rejected — no silent zero.
    match numeric_cols.try_numeric() {
        Err(MattenDataError::MissingValue { column, row }) => {
            println!("missing value blocked conversion: column={column}, csv_line={row}");
            assert_eq!(column, "cost");
            assert_eq!(row, 3); // header is line 1, so the south row is line 3
        }
        other => panic!("expected MissingValue, got {other:?}"),
    }

    // Decide explicitly what a missing cost means here, then convert.
    let tensor = numeric_cols.fill_missing(0.0)?.try_numeric()?.to_tensor()?;

    println!("filled shape: {:?}", tensor.shape());
    println!("filled data : {:?}", tensor.as_slice());

    assert_eq!(tensor.shape(), &[3, 2]);
    // Only the missing south/cost was filled; the other cells are untouched.
    assert_eq!(tensor.as_slice(), &[100.0, 40.0, 150.0, 0.0, 120.0, 55.0]);

    println!("data_03_missing_values: OK");
    Ok(())
}

Trait Implementations

impl Clone for NumericTable

fn clone(&self) -> NumericTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NumericTable

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

Formats the value using the given formatter.