Struct IntegratorConfig 

pub struct IntegratorConfig {
    pub abs_tol: f64,
    pub rel_tol: f64,
    pub initial_step: Option<f64>,
    pub min_step: Option<f64>,
    pub max_step: Option<f64>,
    pub step_safety_factor: Option<f64>,
    pub min_step_scale_factor: Option<f64>,
    pub max_step_scale_factor: Option<f64>,
    pub max_step_attempts: usize,
    pub fixed_step_size: Option<f64>,
}

Configuration options for numerical integrators.

Example

use brahe::integrators::IntegratorConfig;

// Create config with tight tolerances for high-precision integration
let config = IntegratorConfig {
    abs_tol: 1e-12,
    rel_tol: 1e-9,
    max_step: Some(100.0),
    ..Default::default()
};

Fields

abs_tol: f64

Absolute error tolerance for adaptive stepping

rel_tol: f64

Relative error tolerance for adaptive stepping

initial_step: Option<f64>

Initial step size (if None, integrator determines automatically)

min_step: Option<f64>

Minimum allowed step size (if None, no minimum enforced)

max_step: Option<f64>

Maximum allowed step size (if None, no maximum enforced)

step_safety_factor: Option<f64>

Safety factor for adaptive step size control (typically 0.8-0.9) If None, no safety factor applied (uses raw error-based scaling)

min_step_scale_factor: Option<f64>

Minimum step size scaling factor (prevents too-aggressive decreases) If None, no minimum limit on step reduction

max_step_scale_factor: Option<f64>

Maximum step size scaling factor (prevents too-aggressive increases) If None, no maximum limit on step growth

max_step_attempts: usize

Maximum attempts to find acceptable step size

fixed_step_size: Option<f64>

Fixed step size for fixed-step integrators When set, fixed-step integrators will use this value if no dt is provided to step()

Implementations

impl IntegratorConfig

pub fn fixed_step(step_size: f64) -> Self

Create a new configuration for fixed-step integration.

Sets the fixed step size that will be used by fixed-step integrators when no explicit dt is provided to the step() method. The step size can still be overridden on a per-step basis by providing a dt value.

Arguments

• step_size: The step size to use for fixed-step integration (seconds)

Returns

IntegratorConfig with fixed_step_size set

Example

use brahe::integrators::IntegratorConfig;

// Create config with 1.0 second step size
let config = IntegratorConfig::fixed_step(1.0);
assert_eq!(config.fixed_step_size, Some(1.0));

pub fn adaptive(abs_tol: f64, rel_tol: f64) -> Self

Create a new configuration for adaptive-step integration.

Arguments

• abs_tol: Absolute error tolerance
• rel_tol: Relative error tolerance

Returns

IntegratorConfig configured for adaptive stepping

Example

use brahe::integrators::IntegratorConfig;

let config = IntegratorConfig::adaptive(1e-8, 1e-6);

Trait Implementations

impl Clone for IntegratorConfig

fn clone(&self) -> IntegratorConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IntegratorConfig

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

Formats the value using the given formatter.

impl Default for IntegratorConfig

fn default() -> Self

Default configuration matching typical defaults

• abs_tol: 1e-6
• rel_tol: 1e-3
• initial_step: None (auto-determined)
• min_step: Some(1e-12)
• max_step: Some(900.0) (15 minutes)
• step_safety_factor: Some(0.9)
• min_step_scale_factor: Some(0.2)
• max_step_scale_factor: Some(10.0)
• max_step_attempts: 10
• fixed_step_size: None

impl<'de> Deserialize<'de> for IntegratorConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IntegratorConfig

fn eq(&self, other: &IntegratorConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IntegratorConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IntegratorConfig