ai_kit 0.1.0

Collection of classic AI algorithms with convenient interfaces
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

use datum::Datum;
use rule::*;

fn setup() -> Rule<Datum, Datum> {
    from_json!(Rule<Datum, Datum>, {
      "lhs": [{"vec": [{"str": "x"}, {"var": "?x"}]}],
      "rhs": {"vec": [{"str": "y"}, {"var": "?y"}]},
      "constraints": [
        {"numerical": {"set": {"variable": "?diff", "constant": 25}}},
        {"numerical": {"sum": {"first": "?x", "second": "?y", "third": "?diff"}}}
      ],
    })
}

#[test]
fn test_snowflake() {
    let rule: Rule<Datum, Datum> = setup();

    let expected_snowflake = from_json!(Rule<Datum, Datum>, {
      "lhs": [{"vec": [{"str": "x"}, {"var": "?x::test"}]}],
      "rhs": {"vec": [{"str": "y"}, {"var": "?y::test"}]},
      "constraints": [
        {"numerical": {"set": {"variable": "?diff::test", "constant": 25}}},
        {"numerical": {"sum": {"first": "?x::test", "second": "?y::test", "third": "?diff::test"}}}
      ],
    });

    assert_eq!(rule.snowflake("test".to_string()), expected_snowflake);
}

#[test]
fn test_rule_application() {
    let rule: Rule<Datum, Datum> = setup();
    let initial_datum = from_json!(Datum, {"vec": [{"str": "x"}, {"float": 10}]});
    let expected_datum = from_json!(Datum, {"vec": [{"str": "y"}, {"float": 15}]});
    let expected_bindings: Bindings<Datum> = Bindings::new().set_binding(&"?x".to_string(), Datum::Float(10.0));
    let bindings = rule.input_patterns()[0].unify(&initial_datum, &Bindings::new()).unwrap();
    assert_eq!(bindings, expected_bindings);
    assert_eq!(rule.apply_match(&bindings), Some(vec![expected_datum]));
}

#[test]
fn test_rule_application_with_no_antecedents() {
    let rule = from_json!(Rule<Datum, Datum>, {
      "rhs": {"vec": [{"str": "y"}, {"float": 1}]},
    });
    let expected_datum = from_json!(Datum, {"vec": [{"str": "y"}, {"float": 1}]});
    assert_eq!(rule.apply_match(&Bindings::new()), Some(vec![expected_datum]));
}

#[test]
fn test_rule_reverse_application() {
    let rule: Rule<Datum, Datum> = setup();
    let expected_datum = from_json!(Datum, {"vec": [{"str": "x"}, {"float": 10}]});
    let initial_datum = from_json!(Datum, {"vec": [{"str": "y"}, {"float": 15}]});
    let expected_bindings = Bindings::new()
        .set_binding(&"?diff".to_string(), Datum::Float(25.0))
        .set_binding(&"?x".to_string(), Datum::Float(10.0))
        .set_binding(&"?y".to_string(), Datum::Float(15.0));
    assert_eq!(rule.r_apply_match(&initial_datum), Some((vec![expected_datum], expected_bindings)));
}