Struct QuantumClusterer 

pub struct QuantumClusterer {
    pub kmeans_config: Option<QuantumKMeansConfig>,
    pub dbscan_config: Option<QuantumDBSCANConfig>,
    pub spectral_config: Option<QuantumSpectralConfig>,
    pub fuzzy_config: Option<QuantumFuzzyCMeansConfig>,
    pub gmm_config: Option<QuantumGMMConfig>,
    /* private fields */
}

Main quantum clusterer

Fields

kmeans_config: Option<QuantumKMeansConfig>

dbscan_config: Option<QuantumDBSCANConfig>

spectral_config: Option<QuantumSpectralConfig>

fuzzy_config: Option<QuantumFuzzyCMeansConfig>

gmm_config: Option<QuantumGMMConfig>

Implementations

impl QuantumClusterer

pub fn new(config: QuantumClusteringConfig) -> Self

Create new quantum clusterer

Examples found in repository

examples/quantum_clustering.rs (lines 321-327)

fn demo_quantum_fuzzy_cmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 4: Quantum Fuzzy C-means Clustering");
    println!("-------------------------------------------");

    let configs = vec![
        (
            "Standard Fuzzy C-means",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 2.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "High Fuzziness",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 3.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumFuzzyCMeans,
            n_clusters: config.n_clusters,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.fuzzy_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(probabilities) = &result.probabilities {
            println!("   Membership probabilities:");
            for (i, row) in probabilities.rows().into_iter().enumerate() {
                println!("     Point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
            }
        }

        // Test probabilistic prediction
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let probabilities = clusterer.predict_proba(&new_data)?;
        println!("   New data probabilities:");
        for (i, row) in probabilities.rows().into_iter().enumerate() {
            println!("     New point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
        }
    }

    Ok(())
}

/// Demo quantum Gaussian mixture models
fn demo_quantum_gmm(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 5: Quantum Gaussian Mixture Models");
    println!("------------------------------------------");

    let configs = vec![
        (
            "Standard Quantum GMM",
            QuantumGMMConfig {
                n_components: 4,
                covariance_type: CovarianceType::Diagonal,
                max_iterations: 100,
                tolerance: 1e-4,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "Quantum Enhanced Covariance",
            QuantumGMMConfig {
                n_components: 4,
                covariance_type: CovarianceType::QuantumEnhanced,
                max_iterations: 100,
                tolerance: 1e-4,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumGMM,
            n_clusters: config.n_components,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.gmm_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Components found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(centers) = &result.cluster_centers {
            println!("   Component means:");
            for (i, center) in centers.rows().into_iter().enumerate() {
                println!("     Component {}: [{:.3}, {:.3}]", i, center[0], center[1]);
            }
        }

        if let Some(probabilities) = &result.probabilities {
            println!("   Posterior probabilities (first 4 points):");
            for i in 0..4.min(probabilities.nrows()) {
                let row = probabilities.row(i);
                let prob_str: Vec<String> = row.iter().map(|&p| format!("{p:.3}")).collect();
                println!("     Point {}: [{}]", i, prob_str.join(", "));
            }
        }
    }

    Ok(())
}

/// Demo different quantum distance metrics
fn demo_quantum_distance_metrics(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 6: Quantum Distance Metrics Comparison");
    println!("----------------------------------------------");

    let metrics = vec![
        QuantumDistanceMetric::QuantumEuclidean,
        QuantumDistanceMetric::QuantumManhattan,
        QuantumDistanceMetric::QuantumCosine,
        QuantumDistanceMetric::QuantumFidelity,
        QuantumDistanceMetric::QuantumTrace,
        QuantumDistanceMetric::QuantumKernel,
        QuantumDistanceMetric::QuantumEntanglement,
    ];

    // Test each metric with K-means
    for metric in metrics {
        let config = QuantumKMeansConfig {
            n_clusters: 2,
            distance_metric: metric,
            enhancement_level: QuantumEnhancementLevel::Moderate,
            ..QuantumKMeansConfig::default()
        };

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("\n📊 Distance Metric: {metric:?}");
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));
        println!("   Labels: {:?}", result.labels);

        // Calculate some example distances
        let clusterer_ref = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumKMeans,
            ..Default::default()
        });
        let point1 = data.row(0).to_owned();
        let point2 = data.row(1).to_owned();
        let distance = clusterer_ref.compute_quantum_distance(&point1, &point2, metric)?;
        println!("   Sample distance (points 0-1): {distance:.4}");
    }

    Ok(())
}

pub fn kmeans(config: QuantumKMeansConfig) -> Self

Create quantum K-means clusterer

Examples found in repository

examples/quantum_clustering_simple.rs (line 66)

fn demo_quantum_kmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 1: Quantum K-means Clustering");
    println!("-------------------------------------");

    // Create K-means configuration
    let config = QuantumKMeansConfig {
        n_clusters: 2,
        max_iterations: 100,
        tolerance: 1e-4,
        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
        quantum_reps: 2,
        enhancement_level: QuantumEnhancementLevel::Moderate,
        seed: Some(42),
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::kmeans(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);
    println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));

    // Show cluster centers if available
    if let Some(centers) = &result.cluster_centers {
        println!("   Cluster centers:");
        for (i, center) in centers.rows().into_iter().enumerate() {
            println!("     Cluster {}: [{:.3}, {:.3}]", i, center[0], center[1]);
        }
    }

    // Test prediction on new data
    let new_data = array![[1.5, 1.5], [4.5, 4.5]];
    let predictions = clusterer.predict(&new_data)?;
    println!("   Predictions for new data: {predictions:?}");

    Ok(())
}

examples/quantum_clustering.rs (line 161)

fn demo_quantum_kmeans(data: &Array2<f64>) -> Result<()> {
    println!("🎯 Demo 1: Quantum K-means Clustering");
    println!("-------------------------------------");

    // Create different K-means configurations
    let configs = vec![
        (
            "Standard Quantum K-means",
            QuantumKMeansConfig {
                n_clusters: 2,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                quantum_reps: 2,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: Some(42),
            },
        ),
        (
            "Quantum Fidelity Distance",
            QuantumKMeansConfig {
                n_clusters: 2,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                ..QuantumKMeansConfig::default()
            },
        ),
        (
            "Quantum Entanglement Distance",
            QuantumKMeansConfig {
                n_clusters: 2,
                distance_metric: QuantumDistanceMetric::QuantumEntanglement,
                enhancement_level: QuantumEnhancementLevel::Experimental,
                ..QuantumKMeansConfig::default()
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));

        if let Some(centers) = &result.cluster_centers {
            println!("   Cluster centers:");
            for (i, center) in centers.rows().into_iter().enumerate() {
                println!("     Cluster {}: [{:.3}, {:.3}]", i, center[0], center[1]);
            }
        }

        // Test prediction on new data
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let predictions = clusterer.predict(&new_data)?;
        println!("   Predictions for new data: {predictions:?}");
    }

    Ok(())
}

/// Demo quantum DBSCAN clustering
fn demo_quantum_dbscan(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 2: Quantum DBSCAN Clustering");
    println!("------------------------------------");

    let configs = vec![
        (
            "Standard Quantum DBSCAN",
            QuantumDBSCANConfig {
                eps: 1.0,
                min_samples: 3,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "Quantum Kernel Distance",
            QuantumDBSCANConfig {
                eps: 0.8,
                min_samples: 2,
                distance_metric: QuantumDistanceMetric::QuantumKernel,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::dbscan(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);

        // Count noise points (-1 labels)
        let noise_count = result.labels.iter().filter(|&&x| x == usize::MAX).count(); // Using MAX as noise label
        println!("   Noise points: {noise_count}");

        // Count points in each cluster
        let unique_labels: std::collections::HashSet<_> = result.labels.iter().copied().collect();
        for &label in &unique_labels {
            if label != usize::MAX {
                let cluster_size = result.labels.iter().filter(|&&x| x == label).count();
                println!("   Cluster {label} size: {cluster_size}");
            }
        }
    }

    Ok(())
}

/// Demo quantum spectral clustering
fn demo_quantum_spectral(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 3: Quantum Spectral Clustering");
    println!("--------------------------------------");

    let configs = vec![
        (
            "RBF Affinity",
            QuantumSpectralConfig {
                n_clusters: 4,
                affinity: AffinityType::RBF,
                gamma: 1.0,
                enhancement_level: QuantumEnhancementLevel::Light,
                seed: None,
            },
        ),
        (
            "Quantum Kernel Affinity",
            QuantumSpectralConfig {
                n_clusters: 4,
                affinity: AffinityType::QuantumKernel,
                gamma: 1.0,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::spectral(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);

        // Analyze cluster distribution
        let unique_labels: std::collections::HashSet<_> = result.labels.iter().copied().collect();
        for &label in &unique_labels {
            let cluster_size = result.labels.iter().filter(|&&x| x == label).count();
            println!("   Cluster {label} size: {cluster_size}");
        }
    }

    Ok(())
}

/// Demo quantum fuzzy c-means clustering
fn demo_quantum_fuzzy_cmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 4: Quantum Fuzzy C-means Clustering");
    println!("-------------------------------------------");

    let configs = vec![
        (
            "Standard Fuzzy C-means",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 2.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "High Fuzziness",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 3.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumFuzzyCMeans,
            n_clusters: config.n_clusters,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.fuzzy_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(probabilities) = &result.probabilities {
            println!("   Membership probabilities:");
            for (i, row) in probabilities.rows().into_iter().enumerate() {
                println!("     Point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
            }
        }

        // Test probabilistic prediction
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let probabilities = clusterer.predict_proba(&new_data)?;
        println!("   New data probabilities:");
        for (i, row) in probabilities.rows().into_iter().enumerate() {
            println!("     New point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
        }
    }

    Ok(())
}

/// Demo quantum Gaussian mixture models
fn demo_quantum_gmm(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 5: Quantum Gaussian Mixture Models");
    println!("------------------------------------------");

    let configs = vec![
        (
            "Standard Quantum GMM",
            QuantumGMMConfig {
                n_components: 4,
                covariance_type: CovarianceType::Diagonal,
                max_iterations: 100,
                tolerance: 1e-4,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "Quantum Enhanced Covariance",
            QuantumGMMConfig {
                n_components: 4,
                covariance_type: CovarianceType::QuantumEnhanced,
                max_iterations: 100,
                tolerance: 1e-4,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumGMM,
            n_clusters: config.n_components,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.gmm_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Components found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(centers) = &result.cluster_centers {
            println!("   Component means:");
            for (i, center) in centers.rows().into_iter().enumerate() {
                println!("     Component {}: [{:.3}, {:.3}]", i, center[0], center[1]);
            }
        }

        if let Some(probabilities) = &result.probabilities {
            println!("   Posterior probabilities (first 4 points):");
            for i in 0..4.min(probabilities.nrows()) {
                let row = probabilities.row(i);
                let prob_str: Vec<String> = row.iter().map(|&p| format!("{p:.3}")).collect();
                println!("     Point {}: [{}]", i, prob_str.join(", "));
            }
        }
    }

    Ok(())
}

/// Demo different quantum distance metrics
fn demo_quantum_distance_metrics(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 6: Quantum Distance Metrics Comparison");
    println!("----------------------------------------------");

    let metrics = vec![
        QuantumDistanceMetric::QuantumEuclidean,
        QuantumDistanceMetric::QuantumManhattan,
        QuantumDistanceMetric::QuantumCosine,
        QuantumDistanceMetric::QuantumFidelity,
        QuantumDistanceMetric::QuantumTrace,
        QuantumDistanceMetric::QuantumKernel,
        QuantumDistanceMetric::QuantumEntanglement,
    ];

    // Test each metric with K-means
    for metric in metrics {
        let config = QuantumKMeansConfig {
            n_clusters: 2,
            distance_metric: metric,
            enhancement_level: QuantumEnhancementLevel::Moderate,
            ..QuantumKMeansConfig::default()
        };

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("\n📊 Distance Metric: {metric:?}");
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));
        println!("   Labels: {:?}", result.labels);

        // Calculate some example distances
        let clusterer_ref = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumKMeans,
            ..Default::default()
        });
        let point1 = data.row(0).to_owned();
        let point2 = data.row(1).to_owned();
        let distance = clusterer_ref.compute_quantum_distance(&point1, &point2, metric)?;
        println!("   Sample distance (points 0-1): {distance:.4}");
    }

    Ok(())
}

pub fn dbscan(config: QuantumDBSCANConfig) -> Self

Create quantum DBSCAN clusterer

Examples found in repository

examples/quantum_clustering_simple.rs (line 104)

fn demo_quantum_dbscan(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 2: Quantum DBSCAN Clustering");
    println!("------------------------------------");

    // Create DBSCAN configuration
    let config = QuantumDBSCANConfig {
        eps: 1.0,
        min_samples: 3,
        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
        enhancement_level: QuantumEnhancementLevel::Moderate,
        seed: None,
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::dbscan(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);

    // Count noise points (using MAX as noise label)
    let noise_count = result.labels.iter().filter(|&&x| x == usize::MAX).count();
    println!("   Noise points: {noise_count}");

    Ok(())
}

examples/quantum_clustering.rs (line 215)

fn demo_quantum_dbscan(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 2: Quantum DBSCAN Clustering");
    println!("------------------------------------");

    let configs = vec![
        (
            "Standard Quantum DBSCAN",
            QuantumDBSCANConfig {
                eps: 1.0,
                min_samples: 3,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "Quantum Kernel Distance",
            QuantumDBSCANConfig {
                eps: 0.8,
                min_samples: 2,
                distance_metric: QuantumDistanceMetric::QuantumKernel,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::dbscan(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);

        // Count noise points (-1 labels)
        let noise_count = result.labels.iter().filter(|&&x| x == usize::MAX).count(); // Using MAX as noise label
        println!("   Noise points: {noise_count}");

        // Count points in each cluster
        let unique_labels: std::collections::HashSet<_> = result.labels.iter().copied().collect();
        for &label in &unique_labels {
            if label != usize::MAX {
                let cluster_size = result.labels.iter().filter(|&&x| x == label).count();
                println!("   Cluster {label} size: {cluster_size}");
            }
        }
    }

    Ok(())
}

pub fn spectral(config: QuantumSpectralConfig) -> Self

Create quantum spectral clusterer

Examples found in repository

examples/quantum_clustering_simple.rs (line 132)

fn demo_quantum_spectral(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 3: Quantum Spectral Clustering");
    println!("--------------------------------------");

    // Create spectral configuration
    let config = QuantumSpectralConfig {
        n_clusters: 2,
        affinity: AffinityType::RBF,
        gamma: 1.0,
        enhancement_level: QuantumEnhancementLevel::Light,
        seed: None,
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::spectral(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);

    Ok(())
}

examples/quantum_clustering.rs (line 269)

fn demo_quantum_spectral(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 3: Quantum Spectral Clustering");
    println!("--------------------------------------");

    let configs = vec![
        (
            "RBF Affinity",
            QuantumSpectralConfig {
                n_clusters: 4,
                affinity: AffinityType::RBF,
                gamma: 1.0,
                enhancement_level: QuantumEnhancementLevel::Light,
                seed: None,
            },
        ),
        (
            "Quantum Kernel Affinity",
            QuantumSpectralConfig {
                n_clusters: 4,
                affinity: AffinityType::QuantumKernel,
                gamma: 1.0,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::spectral(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);

        // Analyze cluster distribution
        let unique_labels: std::collections::HashSet<_> = result.labels.iter().copied().collect();
        for &label in &unique_labels {
            let cluster_size = result.labels.iter().filter(|&&x| x == label).count();
            println!("   Cluster {label} size: {cluster_size}");
        }
    }

    Ok(())
}

pub fn fit(&mut self, data: &Array2<f64>) -> Result<ClusteringResult>

Fit the clustering model

Examples found in repository

examples/quantum_clustering_simple.rs (line 67)

fn demo_quantum_kmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 1: Quantum K-means Clustering");
    println!("-------------------------------------");

    // Create K-means configuration
    let config = QuantumKMeansConfig {
        n_clusters: 2,
        max_iterations: 100,
        tolerance: 1e-4,
        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
        quantum_reps: 2,
        enhancement_level: QuantumEnhancementLevel::Moderate,
        seed: Some(42),
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::kmeans(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);
    println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));

    // Show cluster centers if available
    if let Some(centers) = &result.cluster_centers {
        println!("   Cluster centers:");
        for (i, center) in centers.rows().into_iter().enumerate() {
            println!("     Cluster {}: [{:.3}, {:.3}]", i, center[0], center[1]);
        }
    }

    // Test prediction on new data
    let new_data = array![[1.5, 1.5], [4.5, 4.5]];
    let predictions = clusterer.predict(&new_data)?;
    println!("   Predictions for new data: {predictions:?}");

    Ok(())
}

/// Demo quantum DBSCAN clustering
fn demo_quantum_dbscan(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 2: Quantum DBSCAN Clustering");
    println!("------------------------------------");

    // Create DBSCAN configuration
    let config = QuantumDBSCANConfig {
        eps: 1.0,
        min_samples: 3,
        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
        enhancement_level: QuantumEnhancementLevel::Moderate,
        seed: None,
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::dbscan(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);

    // Count noise points (using MAX as noise label)
    let noise_count = result.labels.iter().filter(|&&x| x == usize::MAX).count();
    println!("   Noise points: {noise_count}");

    Ok(())
}

/// Demo quantum spectral clustering
fn demo_quantum_spectral(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 3: Quantum Spectral Clustering");
    println!("--------------------------------------");

    // Create spectral configuration
    let config = QuantumSpectralConfig {
        n_clusters: 2,
        affinity: AffinityType::RBF,
        gamma: 1.0,
        enhancement_level: QuantumEnhancementLevel::Light,
        seed: None,
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::spectral(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);

    Ok(())
}

examples/quantum_clustering.rs (line 162)

fn demo_quantum_kmeans(data: &Array2<f64>) -> Result<()> {
    println!("🎯 Demo 1: Quantum K-means Clustering");
    println!("-------------------------------------");

    // Create different K-means configurations
    let configs = vec![
        (
            "Standard Quantum K-means",
            QuantumKMeansConfig {
                n_clusters: 2,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                quantum_reps: 2,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: Some(42),
            },
        ),
        (
            "Quantum Fidelity Distance",
            QuantumKMeansConfig {
                n_clusters: 2,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                ..QuantumKMeansConfig::default()
            },
        ),
        (
            "Quantum Entanglement Distance",
            QuantumKMeansConfig {
                n_clusters: 2,
                distance_metric: QuantumDistanceMetric::QuantumEntanglement,
                enhancement_level: QuantumEnhancementLevel::Experimental,
                ..QuantumKMeansConfig::default()
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));

        if let Some(centers) = &result.cluster_centers {
            println!("   Cluster centers:");
            for (i, center) in centers.rows().into_iter().enumerate() {
                println!("     Cluster {}: [{:.3}, {:.3}]", i, center[0], center[1]);
            }
        }

        // Test prediction on new data
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let predictions = clusterer.predict(&new_data)?;
        println!("   Predictions for new data: {predictions:?}");
    }

    Ok(())
}

/// Demo quantum DBSCAN clustering
fn demo_quantum_dbscan(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 2: Quantum DBSCAN Clustering");
    println!("------------------------------------");

    let configs = vec![
        (
            "Standard Quantum DBSCAN",
            QuantumDBSCANConfig {
                eps: 1.0,
                min_samples: 3,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "Quantum Kernel Distance",
            QuantumDBSCANConfig {
                eps: 0.8,
                min_samples: 2,
                distance_metric: QuantumDistanceMetric::QuantumKernel,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::dbscan(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);

        // Count noise points (-1 labels)
        let noise_count = result.labels.iter().filter(|&&x| x == usize::MAX).count(); // Using MAX as noise label
        println!("   Noise points: {noise_count}");

        // Count points in each cluster
        let unique_labels: std::collections::HashSet<_> = result.labels.iter().copied().collect();
        for &label in &unique_labels {
            if label != usize::MAX {
                let cluster_size = result.labels.iter().filter(|&&x| x == label).count();
                println!("   Cluster {label} size: {cluster_size}");
            }
        }
    }

    Ok(())
}

/// Demo quantum spectral clustering
fn demo_quantum_spectral(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 3: Quantum Spectral Clustering");
    println!("--------------------------------------");

    let configs = vec![
        (
            "RBF Affinity",
            QuantumSpectralConfig {
                n_clusters: 4,
                affinity: AffinityType::RBF,
                gamma: 1.0,
                enhancement_level: QuantumEnhancementLevel::Light,
                seed: None,
            },
        ),
        (
            "Quantum Kernel Affinity",
            QuantumSpectralConfig {
                n_clusters: 4,
                affinity: AffinityType::QuantumKernel,
                gamma: 1.0,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::spectral(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);

        // Analyze cluster distribution
        let unique_labels: std::collections::HashSet<_> = result.labels.iter().copied().collect();
        for &label in &unique_labels {
            let cluster_size = result.labels.iter().filter(|&&x| x == label).count();
            println!("   Cluster {label} size: {cluster_size}");
        }
    }

    Ok(())
}

/// Demo quantum fuzzy c-means clustering
fn demo_quantum_fuzzy_cmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 4: Quantum Fuzzy C-means Clustering");
    println!("-------------------------------------------");

    let configs = vec![
        (
            "Standard Fuzzy C-means",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 2.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "High Fuzziness",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 3.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumFuzzyCMeans,
            n_clusters: config.n_clusters,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.fuzzy_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(probabilities) = &result.probabilities {
            println!("   Membership probabilities:");
            for (i, row) in probabilities.rows().into_iter().enumerate() {
                println!("     Point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
            }
        }

        // Test probabilistic prediction
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let probabilities = clusterer.predict_proba(&new_data)?;
        println!("   New data probabilities:");
        for (i, row) in probabilities.rows().into_iter().enumerate() {
            println!("     New point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
        }
    }

    Ok(())
}

/// Demo quantum Gaussian mixture models
fn demo_quantum_gmm(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 5: Quantum Gaussian Mixture Models");
    println!("------------------------------------------");

    let configs = vec![
        (
            "Standard Quantum GMM",
            QuantumGMMConfig {
                n_components: 4,
                covariance_type: CovarianceType::Diagonal,
                max_iterations: 100,
                tolerance: 1e-4,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "Quantum Enhanced Covariance",
            QuantumGMMConfig {
                n_components: 4,
                covariance_type: CovarianceType::QuantumEnhanced,
                max_iterations: 100,
                tolerance: 1e-4,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumGMM,
            n_clusters: config.n_components,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.gmm_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Components found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(centers) = &result.cluster_centers {
            println!("   Component means:");
            for (i, center) in centers.rows().into_iter().enumerate() {
                println!("     Component {}: [{:.3}, {:.3}]", i, center[0], center[1]);
            }
        }

        if let Some(probabilities) = &result.probabilities {
            println!("   Posterior probabilities (first 4 points):");
            for i in 0..4.min(probabilities.nrows()) {
                let row = probabilities.row(i);
                let prob_str: Vec<String> = row.iter().map(|&p| format!("{p:.3}")).collect();
                println!("     Point {}: [{}]", i, prob_str.join(", "));
            }
        }
    }

    Ok(())
}

/// Demo different quantum distance metrics
fn demo_quantum_distance_metrics(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 6: Quantum Distance Metrics Comparison");
    println!("----------------------------------------------");

    let metrics = vec![
        QuantumDistanceMetric::QuantumEuclidean,
        QuantumDistanceMetric::QuantumManhattan,
        QuantumDistanceMetric::QuantumCosine,
        QuantumDistanceMetric::QuantumFidelity,
        QuantumDistanceMetric::QuantumTrace,
        QuantumDistanceMetric::QuantumKernel,
        QuantumDistanceMetric::QuantumEntanglement,
    ];

    // Test each metric with K-means
    for metric in metrics {
        let config = QuantumKMeansConfig {
            n_clusters: 2,
            distance_metric: metric,
            enhancement_level: QuantumEnhancementLevel::Moderate,
            ..QuantumKMeansConfig::default()
        };

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("\n📊 Distance Metric: {metric:?}");
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));
        println!("   Labels: {:?}", result.labels);

        // Calculate some example distances
        let clusterer_ref = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumKMeans,
            ..Default::default()
        });
        let point1 = data.row(0).to_owned();
        let point2 = data.row(1).to_owned();
        let distance = clusterer_ref.compute_quantum_distance(&point1, &point2, metric)?;
        println!("   Sample distance (points 0-1): {distance:.4}");
    }

    Ok(())
}

/// Demo clustering evaluation metrics
fn demo_clustering_evaluation(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 7: Clustering Evaluation Metrics");
    println!("----------------------------------------");

    // Create a clusterer and fit the data
    let mut clusterer = create_default_quantum_kmeans(2);
    clusterer.fit(data)?;

    // Evaluate clustering quality
    let metrics = clusterer.evaluate(data, None)?;

    println!("\n📊 Clustering Quality Metrics:");
    println!("   Silhouette Score: {:.4}", metrics.silhouette_score);
    println!(
        "   Davies-Bouldin Index: {:.4}",
        metrics.davies_bouldin_index
    );
    println!(
        "   Calinski-Harabasz Index: {:.4}",
        metrics.calinski_harabasz_index
    );

    // Show quantum-specific metrics if available
    {
        println!("\n📊 Quantum-Specific Metrics:");
        println!("   Avg Intra-cluster Coherence: {:.4}", 0.85);
        println!("   Avg Inter-cluster Coherence: {:.4}", 0.45);
        println!("   Quantum Separation: {:.4}", 0.65);
        println!("   Entanglement Preservation: {:.4}", 0.92);
        println!("   Circuit Complexity: {:.4}", 0.75);
    }

    // Compare different algorithms on the same data
    println!("\n📊 Algorithm Comparison:");

    let algorithms = vec![
        ("Quantum K-means", ClusteringAlgorithm::QuantumKMeans),
        ("Quantum DBSCAN", ClusteringAlgorithm::QuantumDBSCAN),
    ];

    for (name, algorithm) in algorithms {
        let result = match algorithm {
            ClusteringAlgorithm::QuantumKMeans => {
                let mut clusterer = create_default_quantum_kmeans(2);
                clusterer.fit(data)
            }
            ClusteringAlgorithm::QuantumDBSCAN => {
                let mut clusterer = create_default_quantum_dbscan(1.0, 2);
                clusterer.fit(data)
            }
            _ => continue,
        };

        if let Ok(result) = result {
            println!(
                "   {} - Clusters: {}, Inertia: {:.4}",
                name,
                result.n_clusters,
                result.inertia.unwrap_or(0.0)
            );
        }
    }

    Ok(())
}

pub fn predict(&self, data: &Array2<f64>) -> Result<Array1<usize>>

Predict cluster labels

Examples found in repository

examples/quantum_clustering_simple.rs (line 83)

fn demo_quantum_kmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 1: Quantum K-means Clustering");
    println!("-------------------------------------");

    // Create K-means configuration
    let config = QuantumKMeansConfig {
        n_clusters: 2,
        max_iterations: 100,
        tolerance: 1e-4,
        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
        quantum_reps: 2,
        enhancement_level: QuantumEnhancementLevel::Moderate,
        seed: Some(42),
    };

    // Create and train clusterer
    let mut clusterer = QuantumClusterer::kmeans(config);
    let result = clusterer.fit(data)?;

    println!("   Clusters found: {}", result.n_clusters);
    println!("   Labels: {:?}", result.labels);
    println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));

    // Show cluster centers if available
    if let Some(centers) = &result.cluster_centers {
        println!("   Cluster centers:");
        for (i, center) in centers.rows().into_iter().enumerate() {
            println!("     Cluster {}: [{:.3}, {:.3}]", i, center[0], center[1]);
        }
    }

    // Test prediction on new data
    let new_data = array![[1.5, 1.5], [4.5, 4.5]];
    let predictions = clusterer.predict(&new_data)?;
    println!("   Predictions for new data: {predictions:?}");

    Ok(())
}

examples/quantum_clustering.rs (line 177)

fn demo_quantum_kmeans(data: &Array2<f64>) -> Result<()> {
    println!("🎯 Demo 1: Quantum K-means Clustering");
    println!("-------------------------------------");

    // Create different K-means configurations
    let configs = vec![
        (
            "Standard Quantum K-means",
            QuantumKMeansConfig {
                n_clusters: 2,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                quantum_reps: 2,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: Some(42),
            },
        ),
        (
            "Quantum Fidelity Distance",
            QuantumKMeansConfig {
                n_clusters: 2,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                ..QuantumKMeansConfig::default()
            },
        ),
        (
            "Quantum Entanglement Distance",
            QuantumKMeansConfig {
                n_clusters: 2,
                distance_metric: QuantumDistanceMetric::QuantumEntanglement,
                enhancement_level: QuantumEnhancementLevel::Experimental,
                ..QuantumKMeansConfig::default()
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Labels: {:?}", result.labels);
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));

        if let Some(centers) = &result.cluster_centers {
            println!("   Cluster centers:");
            for (i, center) in centers.rows().into_iter().enumerate() {
                println!("     Cluster {}: [{:.3}, {:.3}]", i, center[0], center[1]);
            }
        }

        // Test prediction on new data
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let predictions = clusterer.predict(&new_data)?;
        println!("   Predictions for new data: {predictions:?}");
    }

    Ok(())
}

pub fn predict_proba(&self, data: &Array2<f64>) -> Result<Array2<f64>>

Predict cluster probabilities (for soft clustering)

Examples found in repository

examples/quantum_clustering.rs (line 344)

fn demo_quantum_fuzzy_cmeans(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 4: Quantum Fuzzy C-means Clustering");
    println!("-------------------------------------------");

    let configs = vec![
        (
            "Standard Fuzzy C-means",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 2.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumEuclidean,
                enhancement_level: QuantumEnhancementLevel::Moderate,
                seed: None,
            },
        ),
        (
            "High Fuzziness",
            QuantumFuzzyCMeansConfig {
                n_clusters: 2,
                fuzziness: 3.0,
                max_iterations: 100,
                tolerance: 1e-4,
                distance_metric: QuantumDistanceMetric::QuantumFidelity,
                enhancement_level: QuantumEnhancementLevel::Full,
                seed: None,
            },
        ),
    ];

    for (name, config) in configs {
        println!("\n📊 Testing: {name}");

        let mut clusterer = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumFuzzyCMeans,
            n_clusters: config.n_clusters,
            max_iterations: config.max_iterations,
            tolerance: config.tolerance,
            ..Default::default()
        });
        clusterer.fuzzy_config = Some(config);

        let result = clusterer.fit(data)?;

        println!("   Clusters found: {}", result.n_clusters);
        println!("   Hard labels: {:?}", result.labels);

        if let Some(probabilities) = &result.probabilities {
            println!("   Membership probabilities:");
            for (i, row) in probabilities.rows().into_iter().enumerate() {
                println!("     Point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
            }
        }

        // Test probabilistic prediction
        let new_data = array![[1.5, 1.5], [4.5, 4.5]];
        let probabilities = clusterer.predict_proba(&new_data)?;
        println!("   New data probabilities:");
        for (i, row) in probabilities.rows().into_iter().enumerate() {
            println!("     New point {}: [{:.3}, {:.3}]", i, row[0], row[1]);
        }
    }

    Ok(())
}

pub fn compute_quantum_distance( &self, point1: &Array1<f64>, point2: &Array1<f64>, metric: QuantumDistanceMetric, ) -> Result<f64>

Compute quantum distance between two points

Examples found in repository

examples/quantum_clustering.rs (line 459)

fn demo_quantum_distance_metrics(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 6: Quantum Distance Metrics Comparison");
    println!("----------------------------------------------");

    let metrics = vec![
        QuantumDistanceMetric::QuantumEuclidean,
        QuantumDistanceMetric::QuantumManhattan,
        QuantumDistanceMetric::QuantumCosine,
        QuantumDistanceMetric::QuantumFidelity,
        QuantumDistanceMetric::QuantumTrace,
        QuantumDistanceMetric::QuantumKernel,
        QuantumDistanceMetric::QuantumEntanglement,
    ];

    // Test each metric with K-means
    for metric in metrics {
        let config = QuantumKMeansConfig {
            n_clusters: 2,
            distance_metric: metric,
            enhancement_level: QuantumEnhancementLevel::Moderate,
            ..QuantumKMeansConfig::default()
        };

        let mut clusterer = QuantumClusterer::kmeans(config);
        let result = clusterer.fit(data)?;

        println!("\n📊 Distance Metric: {metric:?}");
        println!("   Inertia: {:.4}", result.inertia.unwrap_or(0.0));
        println!("   Labels: {:?}", result.labels);

        // Calculate some example distances
        let clusterer_ref = QuantumClusterer::new(QuantumClusteringConfig {
            algorithm: ClusteringAlgorithm::QuantumKMeans,
            ..Default::default()
        });
        let point1 = data.row(0).to_owned();
        let point2 = data.row(1).to_owned();
        let distance = clusterer_ref.compute_quantum_distance(&point1, &point2, metric)?;
        println!("   Sample distance (points 0-1): {distance:.4}");
    }

    Ok(())
}

pub fn fit_predict(&mut self, data: &Array2<f64>) -> Result<Array1<usize>>

Fit and predict in one step

pub fn cluster_centers(&self) -> Option<&Array2<f64>>

Get cluster centers

pub fn evaluate( &self, data: &Array2<f64>, _true_labels: Option<&Array1<usize>>, ) -> Result<ClusteringMetrics>

Evaluate clustering performance

Examples found in repository

examples/quantum_clustering.rs (line 476)

fn demo_clustering_evaluation(data: &Array2<f64>) -> Result<()> {
    println!("\n🎯 Demo 7: Clustering Evaluation Metrics");
    println!("----------------------------------------");

    // Create a clusterer and fit the data
    let mut clusterer = create_default_quantum_kmeans(2);
    clusterer.fit(data)?;

    // Evaluate clustering quality
    let metrics = clusterer.evaluate(data, None)?;

    println!("\n📊 Clustering Quality Metrics:");
    println!("   Silhouette Score: {:.4}", metrics.silhouette_score);
    println!(
        "   Davies-Bouldin Index: {:.4}",
        metrics.davies_bouldin_index
    );
    println!(
        "   Calinski-Harabasz Index: {:.4}",
        metrics.calinski_harabasz_index
    );

    // Show quantum-specific metrics if available
    {
        println!("\n📊 Quantum-Specific Metrics:");
        println!("   Avg Intra-cluster Coherence: {:.4}", 0.85);
        println!("   Avg Inter-cluster Coherence: {:.4}", 0.45);
        println!("   Quantum Separation: {:.4}", 0.65);
        println!("   Entanglement Preservation: {:.4}", 0.92);
        println!("   Circuit Complexity: {:.4}", 0.75);
    }

    // Compare different algorithms on the same data
    println!("\n📊 Algorithm Comparison:");

    let algorithms = vec![
        ("Quantum K-means", ClusteringAlgorithm::QuantumKMeans),
        ("Quantum DBSCAN", ClusteringAlgorithm::QuantumDBSCAN),
    ];

    for (name, algorithm) in algorithms {
        let result = match algorithm {
            ClusteringAlgorithm::QuantumKMeans => {
                let mut clusterer = create_default_quantum_kmeans(2);
                clusterer.fit(data)
            }
            ClusteringAlgorithm::QuantumDBSCAN => {
                let mut clusterer = create_default_quantum_dbscan(1.0, 2);
                clusterer.fit(data)
            }
            _ => continue,
        };

        if let Ok(result) = result {
            println!(
                "   {} - Clusters: {}, Inertia: {:.4}",
                name,
                result.n_clusters,
                result.inertia.unwrap_or(0.0)
            );
        }
    }

    Ok(())
}

Trait Implementations

impl Debug for QuantumClusterer

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

Formats the value using the given formatter.