Function create_continual_task 

pub fn create_continual_task(
    task_id: String,
    task_type: TaskType,
    data: Array2<f64>,
    labels: Array1<usize>,
    train_ratio: f64,
) -> ContinualTask

Helper function to create a simple continual task

Examples found in repository

examples/quantum_continual_learning.rs (lines 610-616)

fn generate_diverse_tasks(
    num_tasks: usize,
    samples_per_task: usize,
    feature_dim: usize,
) -> Vec<ContinualTask> {
    let mut tasks = Vec::new();

    for i in 0..num_tasks {
        let task_type = match i % 3 {
            0 => "classification",
            1 => "pattern_recognition",
            _ => "feature_detection",
        };

        // Generate task-specific data with different distributions
        let data = Array2::from_shape_fn((samples_per_task, feature_dim), |(row, col)| {
            match i % 3 {
                0 => {
                    // Gaussian-like distribution
                    let center = i as f64 * 0.2;
                    0.2f64.mul_add(fastrand::f64() - 0.5, center)
                }
                1 => {
                    // Sinusoidal pattern
                    let freq = (i + 1) as f64;
                    0.3f64.mul_add(
                        (freq * row as f64).mul_add(0.1, col as f64 * 0.2).sin(),
                        0.5,
                    )
                }
                _ => {
                    // Random with task-specific bias
                    let bias = i as f64 * 0.1;
                    fastrand::f64().mul_add(0.6, bias)
                }
            }
        });

        let labels = Array1::from_shape_fn(samples_per_task, |row| {
            let features_sum = data.row(row).sum();
            usize::from(features_sum > feature_dim as f64 * 0.5)
        });

        let task = create_continual_task(
            format!("{task_type}_{i}"),
            TaskType::Classification { num_classes: 2 },
            data,
            labels,
            0.8,
        );

        tasks.push(task);
    }

    tasks
}

/// Generate related tasks for transfer learning
fn generate_related_tasks(
    num_tasks: usize,
    samples_per_task: usize,
    feature_dim: usize,
) -> Vec<ContinualTask> {
    let mut tasks = Vec::new();
    let base_pattern = Array1::from_shape_fn(feature_dim, |i| (i as f64 * 0.3).sin());

    for i in 0..num_tasks {
        // Each task is a variation of the base pattern
        let variation_strength = (i as f64).mul_add(0.1, 0.1);

        let data = Array2::from_shape_fn((samples_per_task, feature_dim), |(row, col)| {
            let base_value = base_pattern[col];
            let variation = variation_strength * (row as f64).mul_add(0.05, col as f64 * 0.1).cos();
            let noise = 0.05 * (fastrand::f64() - 0.5);
            (base_value + variation + noise).max(0.0).min(1.0)
        });

        let labels = Array1::from_shape_fn(samples_per_task, |row| {
            let correlation = data
                .row(row)
                .iter()
                .zip(base_pattern.iter())
                .map(|(&x, &y)| x * y)
                .sum::<f64>();
            usize::from(correlation > 0.5)
        });

        let task = create_continual_task(
            format!("related_task_{i}"),
            TaskType::Classification { num_classes: 2 },
            data,
            labels,
            0.8,
        );

        tasks.push(task);
    }

    tasks
}

/// Generate tasks with varying complexity
fn generate_varying_complexity_tasks(
    num_tasks: usize,
    samples_per_task: usize,
    feature_dim: usize,
) -> Vec<ContinualTask> {
    let mut tasks = Vec::new();

    for i in 0..num_tasks {
        let complexity = (i + 1) as f64; // Increasing complexity

        let data = Array2::from_shape_fn((samples_per_task, feature_dim), |(row, col)| {
            // More complex decision boundaries for later tasks
            let x = row as f64 / samples_per_task as f64;
            let y = col as f64 / feature_dim as f64;

            let value = match i {
                0 => {
                    if x > 0.5 {
                        1.0
                    } else {
                        0.0
                    }
                } // Simple linear
                1 => {
                    if x.mul_add(x, y * y) > 0.25 {
                        1.0
                    } else {
                        0.0
                    }
                } // Circular
                2 => {
                    if (x * 4.0).sin() * (y * 4.0).cos() > 0.0 {
                        1.0
                    } else {
                        0.0
                    }
                } // Sinusoidal
                _ => {
                    // Very complex pattern
                    let pattern = (x * 8.0)
                        .sin()
                        .mul_add((y * 8.0).cos(), (x * y * 16.0).sin());
                    if pattern > 0.0 {
                        1.0
                    } else {
                        0.0
                    }
                }
            };

            0.1f64.mul_add(fastrand::f64() - 0.5, value) // Add noise
        });

        let labels = Array1::from_shape_fn(samples_per_task, |row| {
            // Complex labeling based on multiple features
            let features = data.row(row);
            let decision_value = features
                .iter()
                .enumerate()
                .map(|(j, &x)| x * (j as f64 * complexity).mul_add(0.1, 1.0))
                .sum::<f64>();

            usize::from(decision_value > feature_dim as f64 * 0.5)
        });

        let task = create_continual_task(
            format!("complex_task_{i}"),
            TaskType::Classification { num_classes: 2 },
            data,
            labels,
            0.8,
        );

        tasks.push(task);
    }

    tasks
}

/// Generate challenging task sequence
fn generate_challenging_sequence(
    num_tasks: usize,
    samples_per_task: usize,
    feature_dim: usize,
) -> Vec<ContinualTask> {
    let mut tasks = Vec::new();

    for i in 0..num_tasks {
        // Alternating between different types of challenges
        let challenge_type = i % 4;

        let data = Array2::from_shape_fn((samples_per_task, feature_dim), |(row, col)| {
            match challenge_type {
                0 => {
                    // High-frequency patterns
                    let freq = (i as f64).mul_add(2.0, 10.0);
                    0.4f64.mul_add((freq * row as f64 * 0.01).sin(), 0.5)
                }
                1 => {
                    // Overlapping distributions
                    let center1 = (i as f64).mul_add(0.05, 0.3);
                    let center2 = (i as f64).mul_add(-0.05, 0.7);
                    if row % 2 == 0 {
                        0.15f64.mul_add(fastrand::f64() - 0.5, center1)
                    } else {
                        0.15f64.mul_add(fastrand::f64() - 0.5, center2)
                    }
                }
                2 => {
                    // Non-linear patterns
                    let x = row as f64 / samples_per_task as f64;
                    let y = col as f64 / feature_dim as f64;
                    let pattern = (i as f64).mul_add(0.1, x.mul_add(x, -(y * y))).tanh();
                    0.3f64.mul_add(pattern, 0.5)
                }
                _ => {
                    // Sparse patterns
                    if fastrand::f64() < 0.2 {
                        0.2f64.mul_add(fastrand::f64(), 0.8)
                    } else {
                        0.1 * fastrand::f64()
                    }
                }
            }
        });

        let labels = Array1::from_shape_fn(samples_per_task, |row| {
            let features = data.row(row);
            match challenge_type {
                0 => usize::from(features.sum() > feature_dim as f64 * 0.5),
                1 => usize::from(features[0] > 0.5),
                2 => usize::from(
                    features
                        .iter()
                        .enumerate()
                        .map(|(j, &x)| x * (j as f64 + 1.0))
                        .sum::<f64>()
                        > 2.0,
                ),
                _ => usize::from(features.iter().filter(|&&x| x > 0.5).count() > feature_dim / 2),
            }
        });

        let task = create_continual_task(
            format!("challenge_{i}"),
            TaskType::Classification { num_classes: 2 },
            data,
            labels,
            0.8,
        );

        tasks.push(task);
    }

    tasks
}

/// Generate tasks with increasing difficulty
fn generate_increasing_difficulty_tasks(
    num_tasks: usize,
    samples_per_task: usize,
    feature_dim: usize,
) -> Vec<ContinualTask> {
    let mut tasks = Vec::new();

    for i in 0..num_tasks {
        let difficulty = (i + 1) as f64;
        let noise_level = 0.05 + difficulty * 0.02;
        let pattern_complexity = 1.0 + difficulty * 0.5;

        let data = Array2::from_shape_fn((samples_per_task, feature_dim), |(row, col)| {
            let x = row as f64 / samples_per_task as f64;
            let y = col as f64 / feature_dim as f64;

            // Increasingly complex patterns
            let base_pattern = (x * pattern_complexity * std::f64::consts::PI).sin()
                * (y * pattern_complexity * std::f64::consts::PI).cos();

            let pattern_value = 0.3f64.mul_add(base_pattern, 0.5);
            let noise = noise_level * (fastrand::f64() - 0.5);

            (pattern_value + noise).max(0.0).min(1.0)
        });

        let labels = Array1::from_shape_fn(samples_per_task, |row| {
            let features = data.row(row);

            // Increasingly complex decision boundaries
            let decision_value = features
                .iter()
                .enumerate()
                .map(|(j, &x)| {
                    let weight = 1.0 + (j as f64 * difficulty * 0.1).sin();
                    x * weight
                })
                .sum::<f64>();

            let threshold = feature_dim as f64 * 0.5 * (1.0 + difficulty * 0.1);
            usize::from(decision_value > threshold)
        });

        let task = create_continual_task(
            format!("difficulty_{}", i + 1),
            TaskType::Classification { num_classes: 2 },
            data,
            labels,
            0.8,
        );

        tasks.push(task);
    }

    tasks
}