Struct Dataset 

pub struct Dataset {
    pub data: Array2<f64>,
    pub target: Option<Array1<f64>>,
    pub targetnames: Option<Vec<String>>,
    pub featurenames: Option<Vec<String>>,
    pub feature_descriptions: Option<Vec<String>>,
    pub description: Option<String>,
    pub metadata: HashMap<String, String>,
}

Represents a dataset with features, optional targets, and metadata

The Dataset struct is the core data structure for managing machine learning datasets. It stores the feature matrix, optional target values, and rich metadata including feature names, descriptions, and arbitrary key-value pairs.

Examples

use scirs2_core::ndarray::Array2;
use scirs2_datasets::utils::Dataset;

let data = Array2::from_shape_vec((3, 2), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
let dataset = Dataset::new(data, None)
    .with_featurenames(vec!["feature1".to_string(), "feature2".to_string()])
    .with_description("Sample dataset".to_string());

assert_eq!(dataset.n_samples(), 3);
assert_eq!(dataset.n_features(), 2);

Fields

data: Array2<f64>

Features/data matrix (n_samples, n_features)

target: Option<Array1<f64>>

Optional target values

targetnames: Option<Vec<String>>

Optional target names for classification problems

featurenames: Option<Vec<String>>

Optional feature names

feature_descriptions: Option<Vec<String>>

Optional descriptions for each feature

description: Option<String>

Optional dataset description

metadata: HashMap<String, String>

Optional dataset metadata

Implementations

impl Dataset

pub fn new(data: Array2<f64>, target: Option<Array1<f64>>) -> Self

Create a new dataset with the given data and target

Arguments

• data - The feature matrix (n_samples, n_features)
• target - Optional target values (n_samples,)

Returns

A new Dataset instance with empty metadata

Examples

use scirs2_core::ndarray::{Array1, Array2};
use scirs2_datasets::utils::Dataset;

let data = Array2::zeros((100, 5));
let target = Some(Array1::zeros(100));
let dataset = Dataset::new(data, target);

Examples found in repository

examples/datasets_cross_validation_demo.rs (line 21)

fn main() {
    println!("=== Cross-Validation Demonstration ===\n");

    // Create sample dataset
    let data = Array2::from_shape_vec((20, 3), (0..60).map(|x| x as f64 / 10.0).collect()).unwrap();
    let target = Array1::from(
        (0..20)
            .map(|i| if i % 2 == 0 { 0.0 } else { 1.0 })
            .collect::<Vec<_>>(),
    );

    let dataset = Dataset::new(data.clone(), Some(target.clone()))
        .with_description("Sample dataset for cross-validation demo".to_string());

    println!("Dataset info:");
    println!("- Samples: {}", dataset.n_samples());
    println!("- Features: {}", dataset.n_features());
    println!("- Description: {}\n", dataset.description.as_ref().unwrap());

    // Demonstrate K-fold cross-validation
    println!("=== K-Fold Cross-Validation (k=5) ===");
    let k_folds = k_fold_split(dataset.n_samples(), 5, true, Some(42)).unwrap();

    for (i, (train_indices, val_indices)) in k_folds.iter().enumerate() {
        println!(
            "Fold {}: Train, size: {}, Validation size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Train indices: {:?}",
            &train_indices[..5.min(train_indices.len())]
        );
        println!("  Val indices: {val_indices:?}");
    }
    println!();

    // Demonstrate Stratified K-fold cross-validation
    println!("=== Stratified K-Fold Cross-Validation (k=4) ===");
    let stratified_folds = stratified_k_fold_split(&target, 4, true, Some(42)).unwrap();

    for (i, (train_indices, val_indices)) in stratified_folds.iter().enumerate() {
        // Calculate class distribution in validation set
        let val_targets: Vec<f64> = val_indices.iter().map(|&idx| target[idx]).collect();
        let class_0_count = val_targets.iter().filter(|&&x| x == 0.0).count();
        let class_1_count = val_targets.iter().filter(|&&x| x == 1.0).count();

        println!(
            "Fold {}: Train, size: {}, Validation size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Class distribution in validation: Class 0: {class_0_count}, Class 1: {class_1_count}"
        );
    }
    println!();

    // Demonstrate Time Series cross-validation
    println!("=== Time Series Cross-Validation ===");
    let ts_folds = time_series_split(dataset.n_samples(), 3, 3, 1).unwrap();

    for (i, (train_indices, val_indices)) in ts_folds.iter().enumerate() {
        println!(
            "Split {}: Train, size: {}, Test size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Train range: {} to {}",
            train_indices.first().unwrap_or(&0),
            train_indices.last().unwrap_or(&0)
        );
        println!(
            "  Test range: {} to {}",
            val_indices.first().unwrap_or(&0),
            val_indices.last().unwrap_or(&0)
        );
    }
    println!();

    // Demonstrate usage with Dataset methods
    println!("=== Using Cross-Validation with Dataset ===");
    let first_fold = &k_folds[0];
    let (train_indices, val_indices) = first_fold;

    // Create training subset
    let traindata = data.select(scirs2_core::ndarray::Axis(0), train_indices);
    let train_target = target.select(scirs2_core::ndarray::Axis(0), train_indices);
    let traindataset = Dataset::new(traindata, Some(train_target))
        .with_description("Training fold from K-fold CV".to_string());

    // Create validation subset
    let valdata = data.select(scirs2_core::ndarray::Axis(0), val_indices);
    let val_target = target.select(scirs2_core::ndarray::Axis(0), val_indices);
    let valdataset = Dataset::new(valdata, Some(val_target))
        .with_description("Validation fold from K-fold CV".to_string());

    println!(
        "Training dataset: {} samples, {} features",
        traindataset.n_samples(),
        traindataset.n_features()
    );
    println!(
        "Validation dataset: {} samples, {} features",
        valdataset.n_samples(),
        valdataset.n_features()
    );

    println!("\n=== Cross-Validation Demo Complete ===");
}

examples/sampling_demo.rs (line 45)

fn main() {
    println!("=== Sampling and Bootstrapping Demonstration ===\n");

    // Load the Iris dataset for demonstration
    let iris = load_iris().unwrap();
    let n_samples = iris.n_samples();

    println!("Original Iris dataset:");
    println!("- Samples: {n_samples}");
    println!("- Features: {}", iris.n_features());

    if let Some(target) = &iris.target {
        let class_counts = count_classes(target);
        println!("- Class distribution: {class_counts:?}\n");
    }

    // Demonstrate random sampling without replacement
    println!("=== Random Sampling (without replacement) ===");
    let samplesize = 30;
    let random_indices = random_sample(n_samples, samplesize, false, Some(42)).unwrap();

    println!("Sampled {samplesize} indices from {n_samples} total samples");
    println!(
        "Sample indices: {:?}",
        &random_indices[..10.min(random_indices.len())]
    );

    // Create a subset dataset
    let sampledata = iris
        .data
        .select(scirs2_core::ndarray::Axis(0), &random_indices);
    let sample_target = iris
        .target
        .as_ref()
        .map(|t| t.select(scirs2_core::ndarray::Axis(0), &random_indices));
    let sampledataset = Dataset::new(sampledata, sample_target)
        .with_description("Random sample from Iris dataset".to_string());

    println!(
        "Random sample dataset: {} samples, {} features",
        sampledataset.n_samples(),
        sampledataset.n_features()
    );

    if let Some(target) = &sampledataset.target {
        let sample_class_counts = count_classes(target);
        println!("Sample class distribution: {sample_class_counts:?}\n");
    }

    // Demonstrate bootstrap sampling (with replacement)
    println!("=== Bootstrap Sampling (with replacement) ===");
    let bootstrapsize = 200; // More than original dataset size
    let bootstrap_indices = random_sample(n_samples, bootstrapsize, true, Some(42)).unwrap();

    println!("Bootstrap sampled {bootstrapsize} indices from {n_samples} total samples");
    println!(
        "Bootstrap may have duplicates - first 10 indices: {:?}",
        &bootstrap_indices[..10]
    );

    // Count frequency of each index in bootstrap sample
    let mut index_counts = vec![0; n_samples];
    for &idx in &bootstrap_indices {
        index_counts[idx] += 1;
    }
    let max_count = *index_counts.iter().max().unwrap();
    let zero_count = index_counts.iter().filter(|&&count| count == 0).count();

    println!("Bootstrap statistics:");
    println!("- Maximum frequency of any sample: {max_count}");
    println!("- Number of original samples not selected: {zero_count}\n");

    // Demonstrate stratified sampling
    println!("=== Stratified Sampling ===");
    if let Some(target) = &iris.target {
        let stratifiedsize = 30;
        let stratified_indices = stratified_sample(target, stratifiedsize, Some(42)).unwrap();

        println!("Stratified sampled {stratifiedsize} indices maintaining class proportions");

        // Create stratified subset
        let stratifieddata = iris
            .data
            .select(scirs2_core::ndarray::Axis(0), &stratified_indices);
        let stratified_target = target.select(scirs2_core::ndarray::Axis(0), &stratified_indices);
        let stratifieddataset = Dataset::new(stratifieddata, Some(stratified_target))
            .with_description("Stratified sample from Iris dataset".to_string());

        println!(
            "Stratified sample dataset: {} samples, {} features",
            stratifieddataset.n_samples(),
            stratifieddataset.n_features()
        );

        let stratified_class_counts = count_classes(&stratifieddataset.target.unwrap());
        println!("Stratified sample class distribution: {stratified_class_counts:?}");

        // Verify proportions are maintained
        let original_proportions = calculate_proportions(&count_classes(target));
        let stratified_proportions = calculate_proportions(&stratified_class_counts);

        println!("Class proportion comparison:");
        for (&class, &original_prop) in &original_proportions {
            let stratified_prop = stratified_proportions.get(&class).unwrap_or(&0.0);
            println!(
                "  Class {}: Original {:.2}%, Stratified {:.2}%",
                class,
                original_prop * 100.0,
                stratified_prop * 100.0
            );
        }
    }

    // Demonstrate practical use case: creating training/validation splits
    println!("\n=== Practical Example: Multiple Train/Validation Splits ===");
    for i in 1..=3 {
        let split_indices = random_sample(n_samples, 100, false, Some(42 + i)).unwrap();
        let (train_indices, val_indices) = split_indices.split_at(80);

        println!(
            "Split {}: {} training samples, {} validation samples",
            i,
            train_indices.len(),
            val_indices.len()
        );
    }

    println!("\n=== Sampling Demo Complete ===");
}

pub fn from_metadata( data: Array2<f64>, target: Option<Array1<f64>>, metadata: DatasetMetadata, ) -> Self

Create a new dataset with the given data, target, and metadata

Arguments

• data - The feature matrix (n_samples, n_features)
• target - Optional target values (n_samples,)
• metadata - Dataset metadata information

Returns

A new Dataset instance with metadata applied

pub fn with_targetnames(self, targetnames: Vec<String>) -> Self

Add target names to the dataset (builder pattern)

Arguments

• targetnames - Vector of target class names

Returns

Self for method chaining

pub fn with_featurenames(self, featurenames: Vec<String>) -> Self

Add feature names to the dataset (builder pattern)

Arguments

• featurenames - Vector of feature names

Returns

Self for method chaining

pub fn with_feature_descriptions(self, featuredescriptions: Vec<String>) -> Self

Add feature descriptions to the dataset (builder pattern)

Arguments

• feature_descriptions - Vector of feature descriptions

Returns

Self for method chaining

pub fn with_description(self, description: String) -> Self

Add a description to the dataset (builder pattern)

Arguments

• description - Dataset description

Returns

Self for method chaining

Examples found in repository

examples/datasets_cross_validation_demo.rs (line 22)

fn main() {
    println!("=== Cross-Validation Demonstration ===\n");

    // Create sample dataset
    let data = Array2::from_shape_vec((20, 3), (0..60).map(|x| x as f64 / 10.0).collect()).unwrap();
    let target = Array1::from(
        (0..20)
            .map(|i| if i % 2 == 0 { 0.0 } else { 1.0 })
            .collect::<Vec<_>>(),
    );

    let dataset = Dataset::new(data.clone(), Some(target.clone()))
        .with_description("Sample dataset for cross-validation demo".to_string());

    println!("Dataset info:");
    println!("- Samples: {}", dataset.n_samples());
    println!("- Features: {}", dataset.n_features());
    println!("- Description: {}\n", dataset.description.as_ref().unwrap());

    // Demonstrate K-fold cross-validation
    println!("=== K-Fold Cross-Validation (k=5) ===");
    let k_folds = k_fold_split(dataset.n_samples(), 5, true, Some(42)).unwrap();

    for (i, (train_indices, val_indices)) in k_folds.iter().enumerate() {
        println!(
            "Fold {}: Train, size: {}, Validation size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Train indices: {:?}",
            &train_indices[..5.min(train_indices.len())]
        );
        println!("  Val indices: {val_indices:?}");
    }
    println!();

    // Demonstrate Stratified K-fold cross-validation
    println!("=== Stratified K-Fold Cross-Validation (k=4) ===");
    let stratified_folds = stratified_k_fold_split(&target, 4, true, Some(42)).unwrap();

    for (i, (train_indices, val_indices)) in stratified_folds.iter().enumerate() {
        // Calculate class distribution in validation set
        let val_targets: Vec<f64> = val_indices.iter().map(|&idx| target[idx]).collect();
        let class_0_count = val_targets.iter().filter(|&&x| x == 0.0).count();
        let class_1_count = val_targets.iter().filter(|&&x| x == 1.0).count();

        println!(
            "Fold {}: Train, size: {}, Validation size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Class distribution in validation: Class 0: {class_0_count}, Class 1: {class_1_count}"
        );
    }
    println!();

    // Demonstrate Time Series cross-validation
    println!("=== Time Series Cross-Validation ===");
    let ts_folds = time_series_split(dataset.n_samples(), 3, 3, 1).unwrap();

    for (i, (train_indices, val_indices)) in ts_folds.iter().enumerate() {
        println!(
            "Split {}: Train, size: {}, Test size: {}",
            i + 1,
            train_indices.len(),
            val_indices.len()
        );
        println!(
            "  Train range: {} to {}",
            train_indices.first().unwrap_or(&0),
            train_indices.last().unwrap_or(&0)
        );
        println!(
            "  Test range: {} to {}",
            val_indices.first().unwrap_or(&0),
            val_indices.last().unwrap_or(&0)
        );
    }
    println!();

    // Demonstrate usage with Dataset methods
    println!("=== Using Cross-Validation with Dataset ===");
    let first_fold = &k_folds[0];
    let (train_indices, val_indices) = first_fold;

    // Create training subset
    let traindata = data.select(scirs2_core::ndarray::Axis(0), train_indices);
    let train_target = target.select(scirs2_core::ndarray::Axis(0), train_indices);
    let traindataset = Dataset::new(traindata, Some(train_target))
        .with_description("Training fold from K-fold CV".to_string());

    // Create validation subset
    let valdata = data.select(scirs2_core::ndarray::Axis(0), val_indices);
    let val_target = target.select(scirs2_core::ndarray::Axis(0), val_indices);
    let valdataset = Dataset::new(valdata, Some(val_target))
        .with_description("Validation fold from K-fold CV".to_string());

    println!(
        "Training dataset: {} samples, {} features",
        traindataset.n_samples(),
        traindataset.n_features()
    );
    println!(
        "Validation dataset: {} samples, {} features",
        valdataset.n_samples(),
        valdataset.n_features()
    );

    println!("\n=== Cross-Validation Demo Complete ===");
}

examples/sampling_demo.rs (line 46)

fn main() {
    println!("=== Sampling and Bootstrapping Demonstration ===\n");

    // Load the Iris dataset for demonstration
    let iris = load_iris().unwrap();
    let n_samples = iris.n_samples();

    println!("Original Iris dataset:");
    println!("- Samples: {n_samples}");
    println!("- Features: {}", iris.n_features());

    if let Some(target) = &iris.target {
        let class_counts = count_classes(target);
        println!("- Class distribution: {class_counts:?}\n");
    }

    // Demonstrate random sampling without replacement
    println!("=== Random Sampling (without replacement) ===");
    let samplesize = 30;
    let random_indices = random_sample(n_samples, samplesize, false, Some(42)).unwrap();

    println!("Sampled {samplesize} indices from {n_samples} total samples");
    println!(
        "Sample indices: {:?}",
        &random_indices[..10.min(random_indices.len())]
    );

    // Create a subset dataset
    let sampledata = iris
        .data
        .select(scirs2_core::ndarray::Axis(0), &random_indices);
    let sample_target = iris
        .target
        .as_ref()
        .map(|t| t.select(scirs2_core::ndarray::Axis(0), &random_indices));
    let sampledataset = Dataset::new(sampledata, sample_target)
        .with_description("Random sample from Iris dataset".to_string());

    println!(
        "Random sample dataset: {} samples, {} features",
        sampledataset.n_samples(),
        sampledataset.n_features()
    );

    if let Some(target) = &sampledataset.target {
        let sample_class_counts = count_classes(target);
        println!("Sample class distribution: {sample_class_counts:?}\n");
    }

    // Demonstrate bootstrap sampling (with replacement)
    println!("=== Bootstrap Sampling (with replacement) ===");
    let bootstrapsize = 200; // More than original dataset size
    let bootstrap_indices = random_sample(n_samples, bootstrapsize, true, Some(42)).unwrap();

    println!("Bootstrap sampled {bootstrapsize} indices from {n_samples} total samples");
    println!(
        "Bootstrap may have duplicates - first 10 indices: {:?}",
        &bootstrap_indices[..10]
    );

    // Count frequency of each index in bootstrap sample
    let mut index_counts = vec![0; n_samples];
    for &idx in &bootstrap_indices {
        index_counts[idx] += 1;
    }
    let max_count = *index_counts.iter().max().unwrap();
    let zero_count = index_counts.iter().filter(|&&count| count == 0).count();

    println!("Bootstrap statistics:");
    println!("- Maximum frequency of any sample: {max_count}");
    println!("- Number of original samples not selected: {zero_count}\n");

    // Demonstrate stratified sampling
    println!("=== Stratified Sampling ===");
    if let Some(target) = &iris.target {
        let stratifiedsize = 30;
        let stratified_indices = stratified_sample(target, stratifiedsize, Some(42)).unwrap();

        println!("Stratified sampled {stratifiedsize} indices maintaining class proportions");

        // Create stratified subset
        let stratifieddata = iris
            .data
            .select(scirs2_core::ndarray::Axis(0), &stratified_indices);
        let stratified_target = target.select(scirs2_core::ndarray::Axis(0), &stratified_indices);
        let stratifieddataset = Dataset::new(stratifieddata, Some(stratified_target))
            .with_description("Stratified sample from Iris dataset".to_string());

        println!(
            "Stratified sample dataset: {} samples, {} features",
            stratifieddataset.n_samples(),
            stratifieddataset.n_features()
        );

        let stratified_class_counts = count_classes(&stratifieddataset.target.unwrap());
        println!("Stratified sample class distribution: {stratified_class_counts:?}");

        // Verify proportions are maintained
        let original_proportions = calculate_proportions(&count_classes(target));
        let stratified_proportions = calculate_proportions(&stratified_class_counts);

        println!("Class proportion comparison:");
        for (&class, &original_prop) in &original_proportions {
            let stratified_prop = stratified_proportions.get(&class).unwrap_or(&0.0);
            println!(
                "  Class {}: Original {:.2}%, Stratified {:.2}%",
                class,
                original_prop * 100.0,
                stratified_prop * 100.0
            );
        }
    }

    // Demonstrate practical use case: creating training/validation splits
    println!("\n=== Practical Example: Multiple Train/Validation Splits ===");
    for i in 1..=3 {
        let split_indices = random_sample(n_samples, 100, false, Some(42 + i)).unwrap();
        let (train_indices, val_indices) = split_indices.split_at(80);

        println!(
            "Split {}: {} training samples, {} validation samples",
            i,
            train_indices.len(),
            val_indices.len()
        );
    }

    println!("\n=== Sampling Demo Complete ===");
}

pub fn with_metadata(self, key: &str, value: &str) -> Self

Add metadata to the dataset (builder pattern)

Arguments

• key - Metadata key
• value - Metadata value

Returns

Self for method chaining

pub fn n_samples(&self) -> usize

Get the number of samples in the dataset

Returns

Number of samples (rows) in the dataset

Examples found in repository

examples/toy_datasets.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let iris = load_iris()?;
    println!("Iris dataset loaded:");
    println!("  Samples: {}", iris.n_samples());
    println!("  Features: {}", iris.n_features());
    println!(
        "  Target classes: {}",
        iris.targetnames.as_ref().map_or(0, |v| v.len())
    );

    let boston = load_boston()?;
    println!("\nBoston Housing dataset loaded:");
    println!("  Samples: {}", boston.n_samples());
    println!("  Features: {}", boston.n_features());

    Ok(())
}

examples/advanced_showcase.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2-Datasets Advanced Mode Showcase");
    println!("===========================================\n");

    // Create a sample dataset for demonstration
    let dataset = create_sampledataset()?;
    println!(
        "📊 Created sample dataset: {} samples, {} features",
        dataset.n_samples(),
        dataset.n_features()
    );

    // Demonstrate advanced analytics
    demonstrate_advanced_analytics(&dataset)?;

    // Demonstrate advanced-GPU optimization
    demonstrate_advanced_gpu_optimization()?;

    // Demonstrate adaptive streaming
    demonstrate_adaptive_streaming(&dataset)?;

    println!("\n✅ Advanced mode demonstration completed successfully!");
    Ok(())
}

examples/csv_loading.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load a CSV file with headers and target column
    let dataset = load_csv_legacy(
        "scirs2-datasets/data/example.csv",
        true,    // has header
        Some(3), // target column index (0-based)
    )?;

    println!("CSV dataset loaded successfully:");
    println!("  Samples: {}", dataset.n_samples());
    println!("  Features: {}", dataset.n_features());
    println!("  Feature names: {:?}", dataset.featurenames);

    // Access data and target
    println!("\nFirst 3 samples:");
    for i in 0..3 {
        let features = dataset.data.row(i);
        let target = dataset.target.as_ref().map(|t| t[i]);
        println!("  Sample {i}: Features = {features:?}, Target = {target:?}");
    }

    Ok(())
}

examples/noise_models_demo.rs (line 203)

fn demonstrate_comprehensive_corruption() {
    println!("Testing comprehensive dataset corruption:");

    // Load a real dataset
    let iris = load_iris().unwrap();
    println!(
        "Original Iris dataset: {} samples, {} features",
        iris.n_samples(),
        iris.n_features()
    );

    let original_stats = calculate_basic_stats(&iris.data);
    println!(
        "Original stats - Mean: {:.3}, Std: {:.3}",
        original_stats.0, original_stats.1
    );

    // Create different levels of corruption
    let corruption_levels = [
        (0.05, 0.02, "Light corruption"),
        (0.1, 0.05, "Moderate corruption"),
        (0.2, 0.1, "Heavy corruption"),
        (0.3, 0.15, "Severe corruption"),
    ];

    for (missing_rate, outlier_rate, description) in corruption_levels {
        let corrupted = make_corrupted_dataset(
            &iris,
            missing_rate,
            MissingPattern::MAR, // More realistic than MCAR
            outlier_rate,
            OutlierType::Point,
            2.5,
            Some(42),
        )
        .unwrap();

        // Calculate how much data is usable
        let total_elements = corrupted.data.len();
        let missing_elements = corrupted.data.iter().filter(|&&x| x.is_nan()).count();
        let usable_percentage =
            ((total_elements - missing_elements) as f64 / total_elements as f64) * 100.0;

        println!("{description}:");
        println!("  Missing data: {:.1}%", missing_rate * 100.0);
        println!("  Outliers: {:.1}%", outlier_rate * 100.0);
        println!("  Usable data: {:.1}%", usable_percentage);

        // Show metadata
        if let Some(missing_count) = corrupted.metadata.get("missing_count") {
            println!("  Actual missing: {missing_count} elements");
        }
        if let Some(outlier_count) = corrupted.metadata.get("outlier_count") {
            println!("  Actual outliers: {outlier_count} samples");
        }
    }
}

examples/time_series_datasets.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Loading time series datasets...\n");

    // Load the electrocardiogram dataset
    let ecg = electrocardiogram()?;

    println!("Electrocardiogram dataset:");
    println!("  Time steps: {}", ecg.n_samples());
    println!("  Features: {}", ecg.n_features());
    println!(
        "  Sampling rate: {} Hz",
        ecg.metadata
            .get("sampling_rate")
            .unwrap_or(&"unknown".to_string())
    );
    println!(
        "  Duration: {}",
        ecg.metadata
            .get("duration")
            .unwrap_or(&"unknown".to_string())
    );

    // Get a slice of the data and display basic statistics
    let ecg_slice = ecg.data.slice(s![0..10, 0]);
    println!("  First 10 data points: {ecg_slice:?}");

    // Calculate some basic statistics
    let ecgdata = ecg.data.column(0);
    let min = ecgdata.fold(f64::INFINITY, |a, &b| a.min(b));
    let max = ecgdata.fold(f64::NEG_INFINITY, |a, &b| a.max(b));
    let mean = ecgdata.sum() / ecgdata.len() as f64;

    println!("  Min: {min:.3} mV");
    println!("  Max: {max:.3} mV");
    println!("  Mean: {mean:.3} mV");

    // Note: Stock market and weather datasets are commented out because their source data
    // is not yet available.

    /*
    // Load the stock market dataset
    println!("\nStock market dataset:");

    // Get price changes (returns)
    let stock_returns = stock_market(true)?;
    println!("  Time steps: {}", stock_returns.n_samples());
    println!("  Companies: {}", stock_returns.n_features());

    // Print companies
    if let Some(featurenames) = &stock_returns.featurenames {
        println!("  Companies: {}", featurenames.join(", "));
    }

    // Load the weather dataset
    println!("\nWeather dataset:");
    let tempdata = weather(Some("temperature"))?;

    println!("  Time steps: {}", tempdata.n_samples());
    println!("  Locations: {}", tempdata.n_features());
    */

    println!("\nTime series dataset loaded successfully!");

    Ok(())
}

examples/dataset_loaders.rs (line 39)

fn main() {
    // Check if a CSV file is provided as a command-line argument
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: {} <path_to_csv_file>", args[0]);
        println!("Example: {} examples/sampledata.csv", args[0]);
        return;
    }

    let filepath = &args[1];

    // Verify the file exists
    if !Path::new(filepath).exists() {
        println!("Error: File '{filepath}' does not exist");
        return;
    }

    // Load CSV file
    println!("Loading CSV file: {filepath}");
    let csv_config = loaders::CsvConfig {
        has_header: true,
        target_column: None,
        ..Default::default()
    };
    match loaders::load_csv(filepath, csv_config) {
        Ok(dataset) => {
            print_dataset_info(&dataset, "Loaded CSV");

            // Split the dataset for demonstration
            println!("\nDemonstrating train-test split...");
            match train_test_split(&dataset, 0.2, Some(42)) {
                Ok((train, test)) => {
                    println!("Training set: {} samples", train.n_samples());
                    println!("Test set: {} samples", test.n_samples());

                    // Save as JSON for demonstration
                    let jsonpath = format!("{filepath}.json");
                    println!("\nSaving training dataset to JSON: {jsonpath}");
                    if let Err(e) = loaders::save_json(&train, &jsonpath) {
                        println!("Error saving JSON: {e}");
                    } else {
                        println!("Successfully saved JSON file");

                        // Load back the JSON file
                        println!("\nLoading back from JSON file...");
                        match loaders::load_json(&jsonpath) {
                            Ok(loaded) => {
                                print_dataset_info(&loaded, "Loaded JSON");
                            }
                            Err(e) => println!("Error loading JSON: {e}"),
                        }
                    }
                }
                Err(e) => println!("Error splitting dataset: {e}"),
            }
        }
        Err(e) => println!("Error loading CSV: {e}"),
    }
}

#[allow(dead_code)]
fn print_dataset_info(dataset: &Dataset, name: &str) {
    println!("=== {name} Dataset ===");
    println!("Number of samples: {}", dataset.n_samples());
    println!("Number of features: {}", dataset.n_features());

    if let Some(featurenames) = &dataset.featurenames {
        println!(
            "Features: {:?}",
            &featurenames[0..std::cmp::min(5, featurenames.len())]
        );
        if featurenames.len() > 5 {
            println!("... and {} more", featurenames.len() - 5);
        }
    }

    if let Some(target) = &dataset.target {
        println!("Target shape: {}", target.len());

        if let Some(targetnames) = &dataset.targetnames {
            println!("Target classes: {targetnames:?}");
        }
    }

    for (key, value) in &dataset.metadata {
        println!("Metadata - {key}: {value}");
    }
}

Additional examples can be found in:

• examples/advanced_generators_demo.rs
• examples/real_world_datasets.rs
• examples/gpu_acceleration.rs
• examples/data_generators.rs
• examples/datasets_streaming_demo.rs
• examples/datasets_cross_validation_demo.rs
• examples/sampling_demo.rs
• examples/feature_extraction_demo.rs
• examples/complex_patterns_demo.rs

pub fn n_features(&self) -> usize

Get the number of features in the dataset

Returns

Number of features (columns) in the dataset

Examples found in repository

examples/toy_datasets.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let iris = load_iris()?;
    println!("Iris dataset loaded:");
    println!("  Samples: {}", iris.n_samples());
    println!("  Features: {}", iris.n_features());
    println!(
        "  Target classes: {}",
        iris.targetnames.as_ref().map_or(0, |v| v.len())
    );

    let boston = load_boston()?;
    println!("\nBoston Housing dataset loaded:");
    println!("  Samples: {}", boston.n_samples());
    println!("  Features: {}", boston.n_features());

    Ok(())
}

examples/advanced_showcase.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 SciRS2-Datasets Advanced Mode Showcase");
    println!("===========================================\n");

    // Create a sample dataset for demonstration
    let dataset = create_sampledataset()?;
    println!(
        "📊 Created sample dataset: {} samples, {} features",
        dataset.n_samples(),
        dataset.n_features()
    );

    // Demonstrate advanced analytics
    demonstrate_advanced_analytics(&dataset)?;

    // Demonstrate advanced-GPU optimization
    demonstrate_advanced_gpu_optimization()?;

    // Demonstrate adaptive streaming
    demonstrate_adaptive_streaming(&dataset)?;

    println!("\n✅ Advanced mode demonstration completed successfully!");
    Ok(())
}

examples/csv_loading.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load a CSV file with headers and target column
    let dataset = load_csv_legacy(
        "scirs2-datasets/data/example.csv",
        true,    // has header
        Some(3), // target column index (0-based)
    )?;

    println!("CSV dataset loaded successfully:");
    println!("  Samples: {}", dataset.n_samples());
    println!("  Features: {}", dataset.n_features());
    println!("  Feature names: {:?}", dataset.featurenames);

    // Access data and target
    println!("\nFirst 3 samples:");
    for i in 0..3 {
        let features = dataset.data.row(i);
        let target = dataset.target.as_ref().map(|t| t[i]);
        println!("  Sample {i}: Features = {features:?}, Target = {target:?}");
    }

    Ok(())
}

examples/dataset_loaders.rs (line 71)

fn print_dataset_info(dataset: &Dataset, name: &str) {
    println!("=== {name} Dataset ===");
    println!("Number of samples: {}", dataset.n_samples());
    println!("Number of features: {}", dataset.n_features());

    if let Some(featurenames) = &dataset.featurenames {
        println!(
            "Features: {:?}",
            &featurenames[0..std::cmp::min(5, featurenames.len())]
        );
        if featurenames.len() > 5 {
            println!("... and {} more", featurenames.len() - 5);
        }
    }

    if let Some(target) = &dataset.target {
        println!("Target shape: {}", target.len());

        if let Some(targetnames) = &dataset.targetnames {
            println!("Target classes: {targetnames:?}");
        }
    }

    for (key, value) in &dataset.metadata {
        println!("Metadata - {key}: {value}");
    }
}

examples/complex_patterns_demo.rs (line 203)

fn print_dataset_summary(dataset: &scirs2_datasets::Dataset, name: &str) {
    let n_classes = if let Some(target) = &dataset.target {
        let unique_labels: std::collections::HashSet<_> =
            target.iter().map(|&x| x as i32).collect();
        unique_labels.len()
    } else {
        0
    };

    let class_info = if n_classes > 0 {
        format!(", {n_classes} classes")
    } else {
        " (unsupervised)".to_string()
    };

    println!(
        "   {}: {} samples, {} features{}",
        name,
        dataset.n_samples(),
        dataset.n_features(),
        class_info
    );

    // Print first few data points for small _datasets
    if dataset.n_samples() <= 10 && dataset.n_features() <= 3 {
        println!("   Sample points:");
        for i in 0..dataset.n_samples().min(3) {
            let point: Vec<f64> = (0..dataset.n_features())
                .map(|j| dataset.data[[i, j]])
                .collect();
            println!(
                "     [{:.3}, {:.3}{}]",
                point[0],
                point[1],
                if point.len() > 2 {
                    format!(", {:.3}", point[2])
                } else {
                    "".to_string()
                }
            );
        }
    }
}

examples/noise_models_demo.rs (line 204)

fn demonstrate_comprehensive_corruption() {
    println!("Testing comprehensive dataset corruption:");

    // Load a real dataset
    let iris = load_iris().unwrap();
    println!(
        "Original Iris dataset: {} samples, {} features",
        iris.n_samples(),
        iris.n_features()
    );

    let original_stats = calculate_basic_stats(&iris.data);
    println!(
        "Original stats - Mean: {:.3}, Std: {:.3}",
        original_stats.0, original_stats.1
    );

    // Create different levels of corruption
    let corruption_levels = [
        (0.05, 0.02, "Light corruption"),
        (0.1, 0.05, "Moderate corruption"),
        (0.2, 0.1, "Heavy corruption"),
        (0.3, 0.15, "Severe corruption"),
    ];

    for (missing_rate, outlier_rate, description) in corruption_levels {
        let corrupted = make_corrupted_dataset(
            &iris,
            missing_rate,
            MissingPattern::MAR, // More realistic than MCAR
            outlier_rate,
            OutlierType::Point,
            2.5,
            Some(42),
        )
        .unwrap();

        // Calculate how much data is usable
        let total_elements = corrupted.data.len();
        let missing_elements = corrupted.data.iter().filter(|&&x| x.is_nan()).count();
        let usable_percentage =
            ((total_elements - missing_elements) as f64 / total_elements as f64) * 100.0;

        println!("{description}:");
        println!("  Missing data: {:.1}%", missing_rate * 100.0);
        println!("  Outliers: {:.1}%", outlier_rate * 100.0);
        println!("  Usable data: {:.1}%", usable_percentage);

        // Show metadata
        if let Some(missing_count) = corrupted.metadata.get("missing_count") {
            println!("  Actual missing: {missing_count} elements");
        }
        if let Some(outlier_count) = corrupted.metadata.get("outlier_count") {
            println!("  Actual outliers: {outlier_count} samples");
        }
    }
}

Additional examples can be found in:

• examples/time_series_datasets.rs
• examples/gpu_acceleration.rs
• examples/advanced_generators_demo.rs
• examples/real_world_datasets.rs
• examples/data_generators.rs
• examples/datasets_cross_validation_demo.rs
• examples/sampling_demo.rs
• examples/feature_extraction_demo.rs

pub fn shape(&self) -> (usize, usize)

Get dataset shape as (n_samples, n_features)

Returns

Tuple of (n_samples, n_features)

pub fn has_target(&self) -> bool

Check if the dataset has target values

Returns

True if target values are present, false otherwise

pub fn featurenames(&self) -> Option<&Vec<String>>

Get a reference to the feature names if available

Returns

Optional reference to feature names vector

Examples found in repository

examples/real_world_datasets.rs (line 121)

fn demonstrate_classification_datasets() -> Result<(), Box<dyn std::error::Error>> {
    println!("🎯 CLASSIFICATION DATASETS");
    println!("{}", "-".repeat(40));

    // Titanic dataset
    println!("Loading Titanic dataset...");
    let titanic = load_titanic()?;

    println!("Titanic Dataset:");
    println!(
        "  Description: {}",
        titanic
            .metadata
            .get("description")
            .unwrap_or(&"Unknown".to_string())
    );
    println!("  Samples: {}", titanic.n_samples());
    println!("  Features: {}", titanic.n_features());

    if let Some(featurenames) = titanic.featurenames() {
        println!("  Features: {featurenames:?}");
    }

    if let Some(targetnames) = titanic.targetnames() {
        println!("  Classes: {targetnames:?}");
    }

    // Analyze class distribution
    if let Some(target) = &titanic.target {
        let mut class_counts = HashMap::new();
        for &class in target.iter() {
            *class_counts.entry(class as i32).or_insert(0) += 1;
        }
        println!("  Class distribution: {class_counts:?}");

        // Calculate survival rate
        let survived = class_counts.get(&1).unwrap_or(&0);
        let total = titanic.n_samples();
        println!(
            "  Survival rate: {:.1}%",
            (*survived as f64 / total as f64) * 100.0
        );
    }

    // Demonstrate train/test split
    let (train, test) = train_test_split(&titanic, 0.2, Some(42))?;
    println!(
        "  Train/test split: {} train, {} test",
        train.n_samples(),
        test.n_samples()
    );

    // Adult (Census Income) dataset
    println!("\nLoading Adult (Census Income) dataset...");
    match load_adult() {
        Ok(adult) => {
            println!("Adult Dataset:");
            println!(
                "  Description: {}",
                adult
                    .metadata
                    .get("description")
                    .unwrap_or(&"Unknown".to_string())
            );
            println!("  Samples: {}", adult.n_samples());
            println!("  Features: {}", adult.n_features());
            println!("  Task: Predict income >$50K based on census data");
        }
        Err(e) => {
            println!("  Note: Adult dataset requires download: {e}");
            println!("  This is expected for the demonstration");
        }
    }

    println!();
    Ok(())
}

#[allow(dead_code)]
fn demonstrate_regression_datasets() -> Result<(), Box<dyn std::error::Error>> {
    println!("📈 REGRESSION DATASETS");
    println!("{}", "-".repeat(40));

    // California Housing dataset
    println!("Loading California Housing dataset...");
    let housing = load_california_housing()?;

    println!("California Housing Dataset:");
    println!(
        "  Description: {}",
        housing
            .metadata
            .get("description")
            .unwrap_or(&"Unknown".to_string())
    );
    println!("  Samples: {}", housing.n_samples());
    println!("  Features: {}", housing.n_features());

    if let Some(featurenames) = housing.featurenames() {
        println!("  Features: {featurenames:?}");
    }

    // Analyze target distribution
    if let Some(target) = &housing.target {
        let mean = target.mean().unwrap_or(0.0);
        let std = target.std(0.0);
        let min = target.iter().fold(f64::INFINITY, |a, &b| a.min(b));
        let max = target.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b));

        println!("  Target (house value) statistics:");
        println!("    Mean: {mean:.2} (hundreds of thousands)");
        println!("    Std:  {std:.2}");
        println!("    Range: [{min:.2}, {max:.2}]");
    }

    // Red Wine Quality dataset
    println!("\nLoading Red Wine Quality dataset...");
    let wine = load_red_wine_quality()?;

    println!("Red Wine Quality Dataset:");
    println!(
        "  Description: {}",
        wine.metadata
            .get("description")
            .unwrap_or(&"Unknown".to_string())
    );
    println!("  Samples: {}", wine.n_samples());
    println!("  Features: {}", wine.n_features());

    if let Some(target) = &wine.target {
        let mean_quality = target.mean().unwrap_or(0.0);
        println!("  Average wine quality: {mean_quality:.1}/10");

        // Quality distribution
        let mut quality_counts = HashMap::new();
        for &quality in target.iter() {
            let q = quality.round() as i32;
            *quality_counts.entry(q).or_insert(0) += 1;
        }
        println!("  Quality distribution: {quality_counts:?}");
    }

    println!();
    Ok(())
}

#[allow(dead_code)]
fn demonstrate_healthcare_datasets() -> Result<(), Box<dyn std::error::Error>> {
    println!("🏥 HEALTHCARE DATASETS");
    println!("{}", "-".repeat(40));

    // Heart Disease dataset
    println!("Loading Heart Disease dataset...");
    let heart = load_heart_disease()?;

    println!("Heart Disease Dataset:");
    println!(
        "  Description: {}",
        heart
            .metadata
            .get("description")
            .unwrap_or(&"Unknown".to_string())
    );
    println!("  Samples: {}", heart.n_samples());
    println!("  Features: {}", heart.n_features());

    if let Some(featurenames) = heart.featurenames() {
        println!("  Clinical features: {:?}", &featurenames[..5]); // Show first 5
        println!("  ... and {} more features", featurenames.len() - 5);
    }

    // Analyze risk factors
    if let Some(target) = &heart.target {
        let mut disease_counts = HashMap::new();
        for &disease in target.iter() {
            *disease_counts.entry(disease as i32).or_insert(0) += 1;
        }

        let with_disease = disease_counts.get(&1).unwrap_or(&0);
        let total = heart.n_samples();
        println!(
            "  Disease prevalence: {:.1}% ({}/{})",
            (*with_disease as f64 / total as f64) * 100.0,
            with_disease,
            total
        );
    }

    // Demonstrate feature analysis
    println!("  Sample clinical parameter ranges:");
    let age_col = heart.data.column(0);
    let age_mean = age_col.mean();
    let age_std = age_col.std(0.0);
    println!("    Age: {age_mean:.1} ± {age_std:.1} years");

    println!();
    Ok(())
}

pub fn targetnames(&self) -> Option<&Vec<String>>

Get a reference to the target names if available

Returns

Optional reference to target names vector

Examples found in repository

examples/real_world_datasets.rs (line 125)

fn demonstrate_classification_datasets() -> Result<(), Box<dyn std::error::Error>> {
    println!("🎯 CLASSIFICATION DATASETS");
    println!("{}", "-".repeat(40));

    // Titanic dataset
    println!("Loading Titanic dataset...");
    let titanic = load_titanic()?;

    println!("Titanic Dataset:");
    println!(
        "  Description: {}",
        titanic
            .metadata
            .get("description")
            .unwrap_or(&"Unknown".to_string())
    );
    println!("  Samples: {}", titanic.n_samples());
    println!("  Features: {}", titanic.n_features());

    if let Some(featurenames) = titanic.featurenames() {
        println!("  Features: {featurenames:?}");
    }

    if let Some(targetnames) = titanic.targetnames() {
        println!("  Classes: {targetnames:?}");
    }

    // Analyze class distribution
    if let Some(target) = &titanic.target {
        let mut class_counts = HashMap::new();
        for &class in target.iter() {
            *class_counts.entry(class as i32).or_insert(0) += 1;
        }
        println!("  Class distribution: {class_counts:?}");

        // Calculate survival rate
        let survived = class_counts.get(&1).unwrap_or(&0);
        let total = titanic.n_samples();
        println!(
            "  Survival rate: {:.1}%",
            (*survived as f64 / total as f64) * 100.0
        );
    }

    // Demonstrate train/test split
    let (train, test) = train_test_split(&titanic, 0.2, Some(42))?;
    println!(
        "  Train/test split: {} train, {} test",
        train.n_samples(),
        test.n_samples()
    );

    // Adult (Census Income) dataset
    println!("\nLoading Adult (Census Income) dataset...");
    match load_adult() {
        Ok(adult) => {
            println!("Adult Dataset:");
            println!(
                "  Description: {}",
                adult
                    .metadata
                    .get("description")
                    .unwrap_or(&"Unknown".to_string())
            );
            println!("  Samples: {}", adult.n_samples());
            println!("  Features: {}", adult.n_features());
            println!("  Task: Predict income >$50K based on census data");
        }
        Err(e) => {
            println!("  Note: Adult dataset requires download: {e}");
            println!("  This is expected for the demonstration");
        }
    }

    println!();
    Ok(())
}

pub fn description(&self) -> Option<&String>

Get a reference to the dataset description if available

Returns

Optional reference to dataset description

pub fn metadata(&self) -> &HashMap<String, String>

Get a reference to the metadata

Returns

Reference to metadata HashMap

pub fn set_metadata(&mut self, key: &str, value: &str)

Add or update a metadata entry

Arguments

• key - Metadata key
• value - Metadata value

pub fn get_metadata(&self, key: &str) -> Option<&String>

Get a metadata value by key

Arguments

• key - Metadata key to lookup

Returns

Optional reference to the metadata value

Trait Implementations

impl Clone for Dataset

fn clone(&self) -> Dataset

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dataset

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Dataset

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Dataset

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

where __S: Serializer,

Serialize this value into the given Serde serializer.