RustedSciThe 0.4.6

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

use RustedSciThe::command_interpreter::task_parser_bvp::{
    parse_bvp_task_from_str, run_bvp_task_from_str,
};
// run cargo run --example bvp_task_shell_guide

fn main() {
    // This is the smallest BVP document that still exercises the full shell:
    // symbolic equations, boundary conditions, mesh, initial guess and solver
    // settings all come from the text-facing layer.
    let task = r#"
task
solver: BVP
strategy: Damped
scheme: forward
method: Sparse

equations
arg: x
unknowns: z, y
rhs: y-z, -z^3

boundary_conditions
z_left: 1.0
y_right: 1.0

mesh
t0: 0.0
t_end: 1.0
n_steps: 20

initial_guess
guess: 0.0, 0.0

solver_options
tolerance: 1e-5
max_iterations: 20
loglevel: off

postprocessing
save_csv: false
plot: false
"#;

    let spec = parse_bvp_task_from_str(task).expect("task should parse");
    println!(
        "parsed BVP task: strategy={:?}, backend={:?}, unknowns={:?}",
        spec.solver.strategy, spec.solver.backend, spec.equations.unknowns
    );

    let result = run_bvp_task_from_str(task).expect("task should solve");
    let matrix = result
        .result
        .expect("solver should produce a result matrix");
    println!("solution shape = {} x {}", matrix.nrows(), matrix.ncols());
}