spindalis 0.4.6

A bioinformatics-focused library for numerical modeling, optimisation, and simulation written in Rust
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

use spindalis::derivatives::simple_derivative;
use spindalis::polynomials::{eval_simple_polynomial, parse_simple_polynomial};
use spindalis::solvers::{Bounds, SolveMode, bisection};

fn main() {
    let polynomial = "-2x^6 - 1.6x^4 + 12x + 1";
    let parsed = parse_simple_polynomial(polynomial).unwrap();
    let error_tol = 1e-5;
    let itermax = 10000;
    println!("The polynomial being evaluated is {polynomial}");

    let result = bisection(
        &parsed,
        simple_derivative,
        eval_simple_polynomial,
        Bounds {
            lower: 0.0,
            init: 0.6,
            upper: 1.0,
        },
        error_tol,
        itermax,
        SolveMode::Extrema,
    );

    match result {
        Ok(x) => {
            println!(
                "Approximate maximum coords between x=0 and x=1: ({x}, {:.5})",
                eval_simple_polynomial(x, &parsed)
            );

            println!(
                "True maximum coords within that range: (0.90449, {:.5})\n",
                eval_simple_polynomial(0.90449, &parsed)
            );
        }
        Err(e) => eprintln!("{e:?}"),
    }

    let params = [
        (
            Bounds {
                lower: -0.2,
                init: -0.05,
                upper: 0.0,
            },
            -0.08333,
        ),
        (
            Bounds {
                lower: 0.0,
                init: 0.6,
                upper: 2.0,
            },
            1.34612,
        ),
    ];
    for (bound, true_root) in params {
        let result = bisection(
            &parsed,
            simple_derivative,
            eval_simple_polynomial,
            bound,
            error_tol,
            itermax,
            SolveMode::Root,
        );

        match result {
            Ok(x) => {
                println!(
                    "Approximate root coords between x=-0.2 and x=0: ({x}, {:.5})",
                    eval_simple_polynomial(x, &parsed)
                );

                println!(
                    "True root coords within that range: ({true_root}, {:.3})\n",
                    eval_simple_polynomial(true_root, &parsed)
                );
            }
            Err(e) => eprintln!("{e:?}\n"),
        }
    }
}