symbolica 0.2.1

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

use symbolica::{
    id::{Condition, Match, MatchSettings, PatternAtomTreeIterator},
    representations::Atom,
    state::{State, Workspace},
};

fn main() {
    let mut state = State::new();
    let workspace = Workspace::default();

    let expr = Atom::parse("f(z)*f(f(x))*f(y)", &mut state, &workspace).unwrap();
    let pat_expr = Atom::parse("f(x_)", &mut state, &workspace).unwrap();

    let pattern = pat_expr.as_view().into_pattern(&state);
    let restrictions = Condition::default();
    let settings = MatchSettings::default();

    println!(
        "> Matching pattern {} to {}:",
        pat_expr.printer(&state),
        expr.printer(&state)
    );

    let mut it =
        PatternAtomTreeIterator::new(&pattern, expr.as_view(), &state, &restrictions, &settings);
    while let Some((location, used_flags, _atom, match_stack)) = it.next() {
        println!("\tMatch at location {:?} - {:?}:", location, used_flags);
        for (id, v) in match_stack {
            print!("\t\t{} = ", state.get_name(*id));
            match v {
                Match::Single(s) => {
                    print!("{}", s.printer(&state))
                }
                Match::Multiple(slice_type, mm) => {
                    print!("{:?} ", slice_type);
                    for vv in mm {
                        print!("{}", vv.printer(&state));
                        print!(", ")
                    }
                }
                Match::FunctionName(f) => {
                    print!("Fn {}", state.get_name(*f))
                }
            }
            println!();
        }
    }
}