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 612-618)

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;
                    center + 0.2 * (fastrand::f64() - 0.5)
                }
                1 => {
                    // Sinusoidal pattern
                    let freq = (i + 1) as f64;
                    0.5 + 0.3 * (freq * row as f64 * 0.1 + col as f64 * 0.2).sin()
                }
                _ => {
                    // Random with task-specific bias
                    let bias = i as f64 * 0.1;
                    bias + fastrand::f64() * 0.6
                }
            }
        });

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

        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 = 0.1 + i as f64 * 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 * 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>();
            if correlation > 0.5 {
                1
            } else {
                0
            }
        });

        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 * 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() * (y * 8.0).cos() + (x * y * 16.0).sin();
                    if pattern > 0.0 {
                        1.0
                    } else {
                        0.0
                    }
                }
            };

            value + 0.1 * (fastrand::f64() - 0.5) // 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 * (1.0 + j as f64 * complexity * 0.1))
                .sum::<f64>();

            if decision_value > feature_dim as f64 * 0.5 {
                1
            } else {
                0
            }
        });

        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 = 10.0 + i as f64 * 2.0;
                    0.5 + 0.4 * (freq * row as f64 * 0.01).sin()
                }
                1 => {
                    // Overlapping distributions
                    let center1 = 0.3 + i as f64 * 0.05;
                    let center2 = 0.7 - i as f64 * 0.05;
                    if row % 2 == 0 {
                        center1 + 0.15 * (fastrand::f64() - 0.5)
                    } else {
                        center2 + 0.15 * (fastrand::f64() - 0.5)
                    }
                }
                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 = (x * x - y * y + i as f64 * 0.1).tanh();
                    0.5 + 0.3 * pattern
                }
                _ => {
                    // Sparse patterns
                    if fastrand::f64() < 0.2 {
                        0.8 + 0.2 * fastrand::f64()
                    } else {
                        0.1 * fastrand::f64()
                    }
                }
            }
        });

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

        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.5 + 0.3 * base_pattern;
            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);
            if decision_value > threshold {
                1
            } else {
                0
            }
        });

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

        tasks.push(task);
    }

    tasks
}