Function k_fold_split 

pub fn k_fold_split(
    n_samples: usize,
    n_folds: usize,
    shuffle: bool,
    random_seed: Option<u64>,
) -> Result<CrossValidationFolds>

Performs K-fold cross-validation splitting

Splits the dataset into k consecutive folds. Each fold is used once as a validation set while the remaining k-1 folds form the training set.

Arguments

• n_samples - Number of samples in the dataset
• n_folds - Number of folds (must be >= 2 and <= n_samples)
• shuffle - Whether to shuffle the data before splitting
• random_seed - Optional random seed for reproducible shuffling

Returns

A vector of (train_indices, validation_indices) tuples for each fold

Examples

use scirs2__datasets::utils::k_fold_split;

let folds = k_fold_split(10, 3, true, Some(42)).unwrap();
assert_eq!(folds.len(), 3);

// Each fold should have roughly equal size
for (train_idx, val_idx) in &folds {
    assert!(val_idx.len() >= 3 && val_idx.len() <= 4);
    assert_eq!(train_idx.len() + val_idx.len(), 10);
}

Examples found in repository

examples/real_world_datasets.rs (line 325)

fn demonstrate_advanced_operations() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔧 ADVANCED DATASET OPERATIONS");
    println!("{}", "-".repeat(40));

    let housing = load_california_housing()?;

    // Data preprocessing pipeline
    println!("Preprocessing pipeline for California Housing:");

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

    // 2. Feature scaling
    let mut pipeline = MLPipeline::default();
    train = pipeline.prepare_dataset(&train)?;
    println!("  2. Standardized features");

    // 3. Cross-validation setup
    let cv_folds = k_fold_split(train.n_samples(), 5, true, Some(42))?;
    println!("  3. Created {} CV folds", cv_folds.len());

    // Feature correlation analysis (simplified)
    println!("  4. Feature analysis:");
    println!("     • {} numerical features", train.n_features());
    println!("     • Ready for machine learning models");

    // Custom dataset configuration
    println!("\nCustom dataset loading configuration:");
    let config = RealWorldConfig {
        use_cache: true,
        download_if_missing: false, // Don't download in demo
        return_preprocessed: true,
        subset: Some("small".to_string()),
        random_state: Some(42),
        ..Default::default()
    };

    println!("  • Caching: {}", config.use_cache);
    println!("  • Download missing: {}", config.download_if_missing);
    println!("  • Preprocessed: {}", config.return_preprocessed);
    println!("  • Subset: {:?}", config.subset);

    println!();
    Ok(())
}

examples/datasets_cross_validation_demo.rs (line 31)

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(ndarray::Axis(0), train_indices);
    let train_target = target.select(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(ndarray::Axis(0), val_indices);
    let val_target = target.select(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 ===");
}