Struct SeparableHamiltonian 

pub struct SeparableHamiltonian<F: IntegrateFloat> { /* private fields */ }

A separable Hamiltonian system with H(q, p) = T(p) + V(q)

This represents systems where the Hamiltonian can be split into kinetic energy T(p) depending only on momenta and potential energy V(q) depending only on positions.

Examples include:

• Simple harmonic oscillator: H = p²/2 + q²/2
• Pendulum: H = p²/2 - cos(q)
• Kepler problem: H = |p|²/2 - 1/|q|

Implementations

impl<F: IntegrateFloat> SeparableHamiltonian<F>

pub fn new<K, V>(_kinetic_energy: K, potentialenergy: V) -> Self

where K: Fn(F, &Array1<F>) -> F + 'static + Send + Sync, V: Fn(F, &Array1<F>) -> F + 'static + Send + Sync,

Create a new separable Hamiltonian system

Arguments

• kinetic_energy - Function computing T(p)
• potential_energy - Function computing V(q)

Returns

A new separable Hamiltonian system

pub fn with_gradients<KG, VG>( self, kinetic_gradient: KG, potentialgradient: VG, ) -> Self

where KG: Fn(F, &Array1<F>) -> Array1<F> + 'static + Send + Sync, VG: Fn(F, &Array1<F>) -> Array1<F> + 'static + Send + Sync,

Add analytical gradient functions for improved performance

Arguments

• kinetic_gradient - Function computing ∇T(p)
• potential_gradient - Function computing ∇V(q)

Returns

Self with gradients configured

pub fn harmonic_oscillator() -> Self

Create a simple harmonic oscillator system

H(q, p) = p²/2 + q²/2

Returns

A harmonic oscillator Hamiltonian

pub fn pendulum() -> Self

Create a pendulum system

H(q, p) = p²/2 - cos(q)

Returns

A pendulum Hamiltonian

pub fn kepler_problem() -> Self

Create a 2D Kepler problem (planetary orbit)

H(q, p) = |p|²/2 - 1/|q|

Returns

A Kepler problem Hamiltonian

Trait Implementations

impl<F: IntegrateFloat> Debug for SeparableHamiltonian<F>

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

Formats the value using the given formatter.

impl<F: IntegrateFloat> HamiltonianFn<F> for SeparableHamiltonian<F>

fn dq_dt( &self, t: F, q: &Array1<F>, p: &Array1<F>, ) -> IntegrateResult<Array1<F>>

Computes the time derivative of position coordinates: dq/dt = ∂H/∂p

fn dp_dt( &self, t: F, q: &Array1<F>, p: &Array1<F>, ) -> IntegrateResult<Array1<F>>

Computes the time derivative of momentum coordinates: dp/dt = -∂H/∂q

fn hamiltonian( &self, ) -> Option<Box<dyn Fn(F, &Array1<F>, &Array1<F>) -> IntegrateResult<F> + '_>>

Optional: Computes the Hamiltonian function H(q, p)