Struct QuantumAnnealing 

pub struct QuantumAnnealing<A: Float + ScalarOperand + Debug> { /* private fields */ }

Quantum annealing optimizer.

QuantumAnnealing performs a Metropolis-based stochastic search where each candidate update is a perturbation of the current parameters whose magnitude is scaled by the current temperature. The acceptance probability blends the classical Boltzmann factor with a quantum-inspired tunneling kernel:

    P(accept) = min(1, exp(-ΔE / (k * T) + Γ * exp(-‖δ‖²)))

where ΔE is approximated by the dot product gradients · δ (treating the supplied gradient as an unbiased local descent direction), Γ is the tunneling strength and δ is the candidate perturbation.

Temperature follows a geometric (exponential) decay

    T(t) = T_initial * (T_final / T_initial)^(t / N)

which is well-behaved for arbitrary positive endpoints and reproduces T(0) = T_initial, T(N) = T_final exactly.

Examples

use optirs_core::quantum_inspired::QuantumAnnealing;
use optirs_core::optimizers::Optimizer;
use scirs2_core::ndarray::Array1;

let mut optimizer: QuantumAnnealing<f64> = QuantumAnnealing::new(0.05)
    .with_temperature_schedule(2.0, 0.01)
    .with_tunneling(0.5)
    .with_seed(123);

let params = Array1::from_vec(vec![1.0, -1.0, 0.5]);
let gradients = params.mapv(|x| 2.0 * x);
let next = optimizer.step(&params, &gradients).expect("step failed");
assert_eq!(next.len(), 3);

Implementations

impl<A> QuantumAnnealing<A>

where A: Float + ScalarOperand + Debug + Send + Sync,

pub fn new(learning_rate: A) -> Self

Creates a new quantum annealing optimizer with the given learning rate and all other parameters set to sensible defaults.

pub fn with_temperature_schedule(self, initial: A, final_t: A) -> Self

Configure the temperature schedule endpoints.

initial must be strictly greater than final_t and both must be positive. The current temperature is reset to initial on each call so chained builders behave intuitively.

pub fn with_tunneling(self, strength: A) -> Self

Configure the tunneling strength Γ.

Larger values increase the average acceptance rate by enlarging the quantum-inspired kernel contribution to the Metropolis exponent.

pub fn with_seed(self, seed: u64) -> Self

Seed the optimizer’s RNG.

pub fn with_iterations(self, num_iterations: usize) -> Self

Configure the number of iterations the cooling schedule spans.

pub fn current_temperature(&self) -> A

Returns the temperature for the current step.

pub fn best_energy(&self) -> A

Returns the best proxy energy discovered so far. Initialised to +∞.

pub fn current_step(&self) -> usize

Returns the current step count.

pub fn initial_temperature(&self) -> A

Returns the configured initial temperature.

pub fn final_temperature(&self) -> A

Returns the configured final temperature.

pub fn tunneling_strength(&self) -> A

Returns the configured tunneling strength.

pub fn num_iterations(&self) -> usize

Returns the configured number of iterations.

pub fn seed(&self) -> u64

Returns the seed used to initialise the RNG.

pub fn learning_rate(&self) -> A

Returns the current learning rate. This is an inherent helper so the caller does not need to qualify a dimension D to invoke the trait implementation of Optimizer::get_learning_rate.

pub fn set_lr(&mut self, learning_rate: A)

Set the learning rate. Inherent helper that mirrors the trait method.

pub fn best_params<D: Dimension>(&self) -> Option<Array<A, D>>

Returns a clone of the best parameters seen so far, reshaped to the requested dimensionality.

pub fn reset(&mut self)

Reset internal step counting and best-state tracking. The RNG is re-seeded with the original seed so the new trajectory is reproducible.

Trait Implementations

impl<A: Debug + Float + ScalarOperand + Debug> Debug for QuantumAnnealing<A>

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

Formats the value using the given formatter.

impl<A, D> Optimizer<A, D> for QuantumAnnealing<A>

where A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension,

fn step( &mut self, params: &Array<A, D>, gradients: &Array<A, D>, ) -> Result<Array<A, D>>

Updates parameters using the given gradients

fn get_learning_rate(&self) -> A

Gets the current learning rate

fn set_learning_rate(&mut self, learning_rate: A)

Sets a new learning rate

fn step_list( &mut self, params_list: &[&Array<A, D>], gradients_list: &[&Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Updates multiple parameter arrays at once