RustedSciThe 0.4.19

Rust framework for symbolic and numerical computing:BVP ( Newton-Raphson frozen/damped/with collocations ), IVP( BDF, Radau, Backward Euler, LSODE, LSODA, RK45, DoPri), nonlinear equations ( Levenberg, Gavin) and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

/// Converts the assembled sparse symbolic/provider bundle into a damped solver runtime state.
pub fn damped_state_from_sparse_solver_bundle(
    bundle: BvpSparseSolverBundle,
    updated_resolver: Option<AotResolver>,
) -> DampedGeneratedSolverState {
    let selected_backend = bundle.effective_backend();
    let bounds_vec = bundle.bounds_vec.clone().unwrap_or_default();
    let rel_tolerance_vec = bundle.rel_tolerance_vec.clone().unwrap_or_default();
    let variable_string = bundle.variable_string.clone();
    let bandwidth = bundle.bandwidth.unwrap_or((0, 0));
    let bc_position_and_value = bundle.bc_position_and_value.clone();
    let runtime_diagnostics = bundle.runtime_diagnostics().clone();
    let generation_telemetry = bundle.generation_telemetry;
    let atom_discretization_telemetry = bundle.atom_discretization_telemetry;
    let legacy_lambdify_telemetry = bundle.legacy_lambdify_telemetry.clone();
    let atom_lambdify_telemetry = bundle.atom_lambdify_telemetry.clone();
    let direct_banded_jacobian_telemetry = bundle.direct_banded_jacobian_telemetry.clone();
    let aot_telemetry = bundle.aot_telemetry.clone();
    let parameter_binding = bundle.parameter_binding.clone();

    let (fun, jac) = bundle
        .into_runtime_callbacks()
        .unwrap_or_else(|| panic!("BVP sparse solver bundle did not provide runtime callbacks"));

    DampedGeneratedSolverState {
        fun,
        jac: Some(jac),
        bounds_vec,
        rel_tolerance_vec,
        variable_string,
        bandwidth,
        bc_position_and_value,
        updated_resolver,
        selected_backend,
        runtime_diagnostics,
        generation_telemetry,
        atom_discretization_telemetry,
        legacy_lambdify_telemetry,
        atom_lambdify_telemetry,
        direct_banded_jacobian_telemetry,
        aot_telemetry,
        parameter_binding,
    }
}

/// Compatibility helper for callers that still hold a legacy [`Jacobian`] instance.
///
/// New code should prefer bundle-based handoff paths instead of converting from
/// raw Jacobian state directly.
pub fn damped_state_from_legacy_jacobian(
    jacobian_instance: Jacobian,
) -> DampedGeneratedSolverState {
    damped_state_from_legacy_solver_bundle(jacobian_instance.into_legacy_solver_bundle())
}

/// Converts a centralized legacy symbolic bundle into the damped solver runtime state.
pub fn damped_state_from_legacy_solver_bundle(
    bundle: BvpLegacySolverBundle,
) -> DampedGeneratedSolverState {
    DampedGeneratedSolverState {
        fun: bundle.residual_function,
        jac: bundle.jacobian_function,
        bounds_vec: bundle.bounds_vec.unwrap_or_default(),
        rel_tolerance_vec: bundle.rel_tolerance_vec.unwrap_or_default(),
        variable_string: bundle.variable_string,
        bandwidth: bundle.bandwidth.unwrap_or((0, 0)),
        bc_position_and_value: bundle.bc_position_and_value,
        updated_resolver: None,
        selected_backend: SelectedBackendKind::Lambdify,
        runtime_diagnostics: HashMap::new(),
        generation_telemetry: None,
        atom_discretization_telemetry: None,
        legacy_lambdify_telemetry: bundle.legacy_lambdify_telemetry,
        atom_lambdify_telemetry: bundle.atom_lambdify_telemetry,
        direct_banded_jacobian_telemetry: bundle.direct_banded_jacobian_telemetry,
        aot_telemetry: None,
        parameter_binding: bundle.parameter_binding,
    }
}

/// Converts the assembled sparse symbolic/provider bundle into a frozen solver runtime state.
pub fn frozen_state_from_sparse_solver_bundle(
    bundle: BvpSparseSolverBundle,
    updated_resolver: Option<AotResolver>,
) -> FrozenGeneratedSolverState {
    let selected_backend = bundle.effective_backend();
    let variable_string = bundle.variable_string.clone();
    let bandwidth = bundle.bandwidth.unwrap_or((0, 0));
    let runtime_diagnostics = bundle.runtime_diagnostics().clone();
    let generation_telemetry = bundle.generation_telemetry;
    let atom_discretization_telemetry = bundle.atom_discretization_telemetry;
    let legacy_lambdify_telemetry = bundle.legacy_lambdify_telemetry.clone();
    let atom_lambdify_telemetry = bundle.atom_lambdify_telemetry.clone();
    let direct_banded_jacobian_telemetry = bundle.direct_banded_jacobian_telemetry.clone();
    let parameter_binding = bundle.parameter_binding.clone();

    let (fun, jac) = bundle.into_runtime_callbacks().unwrap_or_else(|| {
        panic!("Frozen BVP sparse solver bundle did not provide runtime callbacks")
    });

    FrozenGeneratedSolverState {
        fun,
        jac: Some(jac),
        variable_string,
        bandwidth,
        updated_resolver,
        selected_backend,
        runtime_diagnostics,
        generation_telemetry,
        atom_discretization_telemetry,
        legacy_lambdify_telemetry,
        atom_lambdify_telemetry,
        direct_banded_jacobian_telemetry,
        parameter_binding,
    }
}

/// Compatibility helper for callers that still hold a legacy [`Jacobian`] instance.
///
/// New code should prefer bundle-based handoff paths instead of converting from
/// raw Jacobian state directly.
pub fn frozen_state_from_legacy_jacobian(
    jacobian_instance: Jacobian,
) -> FrozenGeneratedSolverState {
    frozen_state_from_legacy_solver_bundle(jacobian_instance.into_legacy_solver_bundle())
}

/// Converts a centralized legacy symbolic bundle into the frozen solver runtime state.
pub fn frozen_state_from_legacy_solver_bundle(
    bundle: BvpLegacySolverBundle,
) -> FrozenGeneratedSolverState {
    FrozenGeneratedSolverState {
        fun: bundle.residual_function,
        jac: bundle.jacobian_function,
        variable_string: bundle.variable_string,
        bandwidth: bundle.bandwidth.unwrap_or((0, 0)),
        updated_resolver: None,
        selected_backend: SelectedBackendKind::Lambdify,
        runtime_diagnostics: HashMap::new(),
        generation_telemetry: None,
        atom_discretization_telemetry: None,
        legacy_lambdify_telemetry: bundle.legacy_lambdify_telemetry,
        atom_lambdify_telemetry: bundle.atom_lambdify_telemetry,
        direct_banded_jacobian_telemetry: bundle.direct_banded_jacobian_telemetry,
        parameter_binding: bundle.parameter_binding,
    }
}