Function make_time_series 

pub fn make_time_series(
    n_samples: usize,
    n_features: usize,
    trend: bool,
    seasonality: bool,
    noise: f64,
    randomseed: Option<u64>,
) -> Result<Dataset>

Generate a random time series dataset

Examples found in repository

examples/noise_models_demo.rs (line 156)

fn demonstrate_time_series_noise() {
    println!("Testing different time series noise types:");

    // Create a simple time series
    let clean_ts = make_time_series(100, 2, true, true, 0.0, Some(42)).unwrap();

    let noise_configs = [
        vec![("gaussian", 0.2)],
        vec![("spikes", 0.1)],
        vec![("drift", 0.5)],
        vec![("seasonal", 0.3)],
        vec![("autocorrelated", 0.1)],
        vec![("heteroscedastic", 0.2)],
        vec![("gaussian", 0.1), ("spikes", 0.05), ("drift", 0.2)], // Combined noise
    ];

    let noisenames = [
        "Gaussian White Noise",
        "Impulse Spikes",
        "Linear Drift",
        "Seasonal Pattern",
        "Autocorrelated Noise",
        "Heteroscedastic Noise",
        "Combined Noise",
    ];

    for (config, name) in noise_configs.iter().zip(noisenames.iter()) {
        let mut noisydata = clean_ts.data.clone();
        let original_stats = calculate_basic_stats(&noisydata);

        add_time_series_noise(&mut noisydata, config, Some(42)).unwrap();
        let noisy_stats = calculate_basic_stats(&noisydata);

        println!("{name}:");
        println!("  Mean: {:.3} -> {:.3}", original_stats.0, noisy_stats.0);
        println!("  Std: {:.3} -> {:.3}", original_stats.1, noisy_stats.1);
        println!(
            "  Range: [{:.3}, {:.3}] -> [{:.3}, {:.3}]",
            original_stats.2, original_stats.3, noisy_stats.2, noisy_stats.3
        );
    }
}

#[allow(dead_code)]
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");
        }
    }
}

#[allow(dead_code)]
fn demonstrate_real_world_applications() {
    println!("Real-world application scenarios:");

    println!("\n1. **Medical Data Simulation**:");
    let medicaldata = load_iris().unwrap(); // Stand-in for medical measurements
    let _corrupted_medical = make_corrupted_dataset(
        &medicaldata,
        0.15,                 // 15% missing - common in medical data
        MissingPattern::MNAR, // High values often missing (privacy, measurement issues)
        0.05,                 // 5% outliers - measurement errors
        OutlierType::Point,
        2.0,
        Some(42),
    )
    .unwrap();

    println!("  Medical dataset simulation:");
    println!("    Missing data pattern: MNAR (high values more likely missing)");
    println!("    Outliers: Point outliers (measurement errors)");
    println!("    Use case: Testing imputation algorithms for clinical data");

    println!("\n2. **Sensor Network Simulation**:");
    let sensordata = make_time_series(200, 4, true, true, 0.1, Some(42)).unwrap();
    let mut sensor_ts = sensordata.data.clone();

    // Add realistic sensor noise
    add_time_series_noise(
        &mut sensor_ts,
        &[
            ("gaussian", 0.05),        // Background noise
            ("spikes", 0.02),          // Electrical interference
            ("drift", 0.1),            // Sensor calibration drift
            ("heteroscedastic", 0.03), // Temperature-dependent noise
        ],
        Some(42),
    )
    .unwrap();

    // Add missing data (sensor failures)
    inject_missing_data(&mut sensor_ts, 0.08, MissingPattern::Block, Some(42)).unwrap();

    println!("  Sensor network simulation:");
    println!("    Multiple noise types: gaussian + spikes + drift + heteroscedastic");
    println!("    Missing data: Block pattern (sensor failures)");
    println!("    Use case: Testing robust time series algorithms");

    println!("\n3. **Survey Data Simulation**:");
    let surveydata = load_iris().unwrap(); // Stand-in for survey responses
    let _corrupted_survey = make_corrupted_dataset(
        &surveydata,
        0.25,                // 25% missing - typical for surveys
        MissingPattern::MAR, // Missing depends on other responses
        0.08,                // 8% outliers - data entry errors, extreme responses
        OutlierType::Contextual,
        1.5,
        Some(42),
    )
    .unwrap();

    println!("  Survey data simulation:");
    println!("    Missing data pattern: MAR (depends on other responses)");
    println!("    Outliers: Contextual (unusual response patterns)");
    println!("    Use case: Testing survey analysis robustness");

    println!("\n4. **Financial Data Simulation**:");
    let mut financial_ts = make_time_series(500, 3, false, false, 0.02, Some(42))
        .unwrap()
        .data;

    // Add financial market-specific noise
    add_time_series_noise(
        &mut financial_ts,
        &[
            ("gaussian", 0.1),        // Market volatility
            ("spikes", 0.05),         // Market shocks
            ("autocorrelated", 0.15), // Momentum effects
            ("heteroscedastic", 0.2), // Volatility clustering
        ],
        Some(42),
    )
    .unwrap();

    println!("  Financial data simulation:");
    println!("    Noise types: volatility + shocks + momentum + clustering");
    println!("    Use case: Testing financial models under realistic conditions");
}

examples/data_generators.rs (lines 77-84)

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

    // Generate classification dataset
    let n_samples = 100;
    let n_features = 5;

    let classificationdata = make_classification(
        n_samples,
        n_features,
        3,        // 3 classes
        2,        // 2 clusters per class
        3,        // 3 informative features
        Some(42), // random seed
    )?;

    // Train-test split
    let (train, test) = train_test_split(&classificationdata, 0.2, Some(42))?;

    println!("Classification dataset:");
    println!("  Total samples: {}", classificationdata.n_samples());
    println!("  Features: {}", classificationdata.n_features());
    println!("  Training samples: {}", train.n_samples());
    println!("  Test samples: {}", test.n_samples());

    // Generate regression dataset
    let regressiondata = make_regression(
        n_samples,
        n_features,
        3,   // 3 informative features
        0.5, // noise level
        Some(42),
    )?;

    println!("\nRegression dataset:");
    println!("  Samples: {}", regressiondata.n_samples());
    println!("  Features: {}", regressiondata.n_features());

    // Normalize the data (in-place)
    let mut data_copy = regressiondata.data.clone();
    normalize(&mut data_copy);
    println!("  Data normalized successfully");

    // Generate clustering data (blobs)
    let clusteringdata = make_blobs(
        n_samples,
        2,   // 2 features for easy visualization
        4,   // 4 clusters
        0.8, // cluster standard deviation
        Some(42),
    )?;

    println!("\nClustering dataset (blobs):");
    println!("  Samples: {}", clusteringdata.n_samples());
    println!("  Features: {}", clusteringdata.n_features());

    // Find the number of clusters by finding the max value of target
    let num_clusters = clusteringdata.target.as_ref().map_or(0, |t| {
        let mut max_val = -1.0;
        for &val in t.iter() {
            if val > max_val {
                max_val = val;
            }
        }
        (max_val as usize) + 1
    });

    println!("  Clusters: {num_clusters}");

    // Generate time series data
    let time_series = make_time_series(
        100,  // 100 time steps
        3,    // 3 features/variables
        true, // with trend
        true, // with seasonality
        0.2,  // noise level
        Some(42),
    )?;

    println!("\nTime series dataset:");
    println!("  Time steps: {}", time_series.n_samples());
    println!("  Features: {}", time_series.n_features());

    Ok(())
}