Struct QuantumSpatialOptimizer 

pub struct QuantumSpatialOptimizer { /* private fields */ }

Quantum Approximate Optimization Algorithm (QAOA) for Spatial Problems

QAOA is a variational quantum algorithm designed to solve combinatorial optimization problems. This implementation focuses on spatial optimization problems such as the traveling salesman problem (TSP), facility location, and graph partitioning.

Features

• QAOA layers with parameterized quantum gates
• Automatic parameter optimization using gradient descent
• TSP solving with quantum state preparation and measurement
• Cost and mixer Hamiltonian implementations
• Adaptive learning rate scheduling

Example

use scirs2_core::ndarray::Array2;
use scirs2_spatial::quantum_inspired::algorithms::QuantumSpatialOptimizer;

// Create distance matrix for TSP
let distance_matrix = Array2::from_shape_vec((4, 4), vec![
    0.0, 1.0, 2.0, 3.0,
    1.0, 0.0, 4.0, 2.0,
    2.0, 4.0, 0.0, 1.0,
    3.0, 2.0, 1.0, 0.0
]).unwrap();

let mut optimizer = QuantumSpatialOptimizer::new(3);
let tour = optimizer.solve_tsp(&distance_matrix).unwrap();
println!("Optimal tour: {:?}", tour);

Implementations

impl QuantumSpatialOptimizer

pub fn new(num_layers: usize) -> Self

Create new QAOA optimizer

Arguments

• num_layers - Number of QAOA layers (typically 1-10)

Returns

A new QuantumSpatialOptimizer with default configuration

pub fn with_max_iterations(self, max_iter: usize) -> Self

Configure maximum iterations

Arguments

• max_iter - Maximum number of optimization iterations

pub fn with_learning_rate(self, lr: f64) -> Self

Configure learning rate

Arguments

• lr - Learning rate for parameter optimization

pub fn with_tolerance(self, tol: f64) -> Self

Configure convergence tolerance

Arguments

• tol - Convergence tolerance

pub fn solve_tsp( &mut self, distance_matrix: &Array2<f64>, ) -> SpatialResult<Vec<usize>>

Solve traveling salesman problem using QAOA

Uses the Quantum Approximate Optimization Algorithm to find an approximate solution to the traveling salesman problem. The algorithm encodes the TSP as a QUBO (Quadratic Unconstrained Binary Optimization) problem and uses quantum superposition to explore multiple tour configurations simultaneously.

Arguments

• distance_matrix - Square matrix of distances between cities

Returns

A tour represented as a vector of city indices

Errors

Returns error if the distance matrix is not square

pub fn solve_qap( &mut self, flow_matrix: &Array2<f64>, distance_matrix: &Array2<f64>, ) -> SpatialResult<Vec<usize>>

Solve quadratic assignment problem using QAOA

Applies QAOA to solve facility location and assignment problems.

Arguments

• flow_matrix - Flow between facilities
• distance_matrix - Distance between locations

Returns

Assignment of facilities to locations

pub fn num_layers(&self) -> usize

Get number of QAOA layers

pub fn beta_params(&self) -> &[f64]

Get current beta parameters

pub fn gamma_params(&self) -> &[f64]

Get current gamma parameters

pub fn cost_history(&self) -> &[f64]

Get cost history

pub fn learning_rate(&self) -> f64

Get current learning rate

Trait Implementations

impl Clone for QuantumSpatialOptimizer

fn clone(&self) -> QuantumSpatialOptimizer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuantumSpatialOptimizer

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

Formats the value using the given formatter.