symbolica 1.0.0

A blazing fast computer algebra system
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

use symbolica::{
    atom::{Atom, AtomCore},
    domains::{float::Complex, rational::Rational},
    evaluate::{CompileOptions, ExportSettings, FunctionMap, InlineASM, OptimizationSettings},
    parse, symbol,
};

fn main() {
    let e1 = parse!("x + pi + cos(x) + f(g(x+1),h(x*2)) + p(1,x)");
    let e2 = parse!("x + h(x*2) + cos(x)");
    let f = parse!("y^2 + z^2*y^2");
    let g = parse!("i(y+7)+x*i(y+7)*(y-1)");
    let h = parse!("y*(1+x*(1+x^2)) + y^2*(1+x*(1+x^2))^2 + 3*(1+x^2)");
    let i = parse!("y - 1");
    let p1 = parse!("3*z^3 + 4*z^2 + 6*z +8");

    let mut fn_map = FunctionMap::new();

    fn_map.add_constant(symbol!("pi").into(), Complex::from(Rational::from((22, 7))));
    fn_map
        .add_tagged_function(
            symbol!("p"),
            vec![Atom::num(1)],
            "p1".to_string(),
            vec![symbol!("z")],
            p1,
        )
        .unwrap();
    fn_map
        .add_function(
            symbol!("f"),
            "f".to_string(),
            vec![symbol!("y"), symbol!("z")],
            f,
        )
        .unwrap();
    fn_map
        .add_function(symbol!("g"), "g".to_string(), vec![symbol!("y")], g)
        .unwrap();
    fn_map
        .add_function(symbol!("h"), "h".to_string(), vec![symbol!("y")], h)
        .unwrap();
    fn_map
        .add_function(symbol!("i"), "i".to_string(), vec![symbol!("y")], i)
        .unwrap();

    let params = vec![parse!("x")];

    let evaluator = Atom::evaluator_multiple(
        &[e1.as_view(), e2.as_view()],
        &fn_map,
        &params,
        OptimizationSettings::default(),
    )
    .unwrap();

    let mut e_f64 = evaluator.map_coeff(&|x| x.to_real().unwrap().into());
    let mut out = vec![0., 0.];
    e_f64.evaluate(&[5.], &mut out);
    println!("{}", out[0]);

    let mut compiled = e_f64
        .export_cpp::<f64>(
            "nested_evaluate.cpp",
            "nested",
            ExportSettings {
                include_header: true,
                inline_asm: InlineASM::default(),
                ..Default::default()
            },
        )
        .unwrap()
        .compile("nested", CompileOptions::default())
        .unwrap()
        .load()
        .unwrap();

    compiled.evaluate(&[5.], &mut out);
    println!("{}", out[0]);
}