def _benchmark_setup(): with kb_context("test_predicate_node"): kb = KnowledgeBase() pn = get_alpha_predicate_node(BOOPType,"B", "<",50) ld = generate_link_data(pn,kb) # kb.add_subscriber(pn) return (kb, pn, ld), {}
def test_predicate_node_sanity(): with kb_context("test_predicate_node_sanity"): BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) kb = KnowledgeBase() pn = get_alpha_predicate_node(BOOPType,"B", "<",9) pnc = cast(pn, BasePredicateNodeType) png = cast(pn, GenericAlphaPredicateNodeType) attrs_pn = np.array([struct_get_attr_offset(pnc,x[0]) for x in base_subscriber_fields+basepredicate_node_fields]) attrs_pnc = np.array([struct_get_attr_offset(pn, x[0]) for x in base_subscriber_fields+alpha_predicate_node_fields]) attrs_png = np.array([struct_get_attr_offset(png,x[0]) for x in base_subscriber_fields+alpha_predicate_node_fields]) assert np.array_equal(attrs_pn,attrs_pnc[:len(attrs_pn)]) assert np.array_equal(attrs_pn,attrs_png[:len(attrs_pn)]) assert np.array_equal(attrs_pnc,attrs_png) ld = generate_link_data(pnc, kb) assert len(filter_alpha(png, ld, np.arange(5)))==0 pn = get_beta_predicate_node(BOOPType,"B", "<", BOOPType,"B") pnc = cast(pn, BasePredicateNodeType) png = cast(pn, GenericBetaPredicateNodeType) ld = generate_link_data(pnc, kb) attrs_pn = np.array([struct_get_attr_offset(pnc,x[0]) for x in base_subscriber_fields+basepredicate_node_fields]) attrs_pnc = np.array([struct_get_attr_offset(pn, x[0]) for x in base_subscriber_fields+beta_predicate_node_fields]) attrs_png = np.array([struct_get_attr_offset(png,x[0]) for x in base_subscriber_fields+beta_predicate_node_fields]) assert np.array_equal(attrs_pn,attrs_pnc[:len(attrs_pn)]) assert np.array_equal(attrs_pn,attrs_png[:len(attrs_pn)]) assert np.array_equal(attrs_pnc,attrs_png) assert len(filter_beta(png, ld, np.arange(5), np.arange(5))) == 0
def test_inheritence(): with kb_context("test_inheritence") as context: spec1 = {"A": "string", "B": "number"} BOOP1, BOOP1Type = define_fact("BOOP1", spec1, context="test_inheritence") spec2 = {"inherit_from": BOOP1, "C": "number"} BOOP2, BOOP2Type = define_fact("BOOP2", spec2, context="test_inheritence") spec3 = {"inherit_from": BOOP2, "D": "number"} BOOP3, BOOP3Type = define_fact("BOOP3", spec3, context="test_inheritence") assert context.parents_of["BOOP3"] == ["BOOP1", "BOOP2"] assert context.children_of["BOOP3"] == [] assert context.parents_of["BOOP2"] == ["BOOP1"] assert context.children_of["BOOP2"] == ["BOOP3"] assert context.parents_of["BOOP1"] == [] assert context.children_of["BOOP1"] == ["BOOP2", "BOOP3"] b1 = BOOP1("A", 7) @njit def check_has_base(b): return b.idrec assert check_has_base(b1) == u8(-1) assert check_has_base.py_func(b1) == u8(-1)
def test_matching(): with kb_context("test_link"): BOOP, BOOPType = define_fact("BOOP", {"A": "string", "B": "number"}) l1, l2 = Var(BOOPType, "l1"), Var(BOOPType, "l2") r1, r2 = Var(BOOPType, "r1"), Var(BOOPType, "r2") c = (l1.B > 0) & (l1.B != 3) & (l1.B < 4) & (l2.B != 3) | \ (l1.B == 3) kb = KnowledgeBase() kb.declare(BOOP("0", 0)) kb.declare(BOOP("1", 1)) kb.declare(BOOP("2", 2)) kb.declare(BOOP("3", 3)) kb.declare(BOOP("4", 4)) cl = get_linked_conditions_instance(c, kb) conditions_get_matches(cl) print("----------") c = (l1.B <= 1) & (l1.B < l2.B) & (l2.B <= r1.B) cl = get_linked_conditions_instance(c, kb) conditions_get_matches(cl)
def test_term(): with kb_context("test_term"): # BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) l1, l2 = Var(BOOPType, "l1"), Var(BOOPType, "l2") c1 = l1.B < 1 print(first_alpha(c1)) # print(c1.dnf[0][0][0].is_alpha) c2 = l1.B < l2.B print(first_beta(c2))
def _beta_setup(): with kb_context("test_predicate_node"): kb = KnowledgeBase() pn = get_beta_predicate_node(BOOPType,"B", "<", BOOPType,"B") # kb.add_subscriber(pn) ld = generate_link_data(pn, kb) idrecs = np.empty((100,),dtype=np.int64) for i in range(100): idrecs[i] = kb.declare(BOOP("?",i)) return (kb, pn, ld, np.arange(100), idrecs), {}
def test_retract_keyerror(): with kb_context("test_retract_keyerror"): #NRT version kb = KnowledgeBase() with pytest.raises(KeyError): retract_keyerror(kb) #Python version kb = KnowledgeBase() with pytest.raises(KeyError): retract_keyerror.py_func(kb)
def test_all_facts_of_type(): with kb_context("test_all_facts_of_type"): #NRT version kb = KnowledgeBase() declare_retract(kb) all_tf = all_of_type(kb) assert isinstance(all_tf[0], TextField) assert len(all_tf) == 90 all_tf = all_of_type.py_func(kb) assert isinstance(all_tf[0], TextField) assert len(all_tf) == 90
def test_protected_mutability(): print("RUNTIME1.") with kb_context("test_protected_mutability") as context: print("RUNTIME1.2") spec = {"A": "string", "B": "number"} BOOP, BOOPType = define_fact("BOOP", spec, context="test_protected_mutability") print("RUNTIME1.3") kb = KnowledgeBase(context="test_protected_mutability") print("RUNTIME1") b1 = BOOP("A", 0) b2 = BOOP("B", 0) print("RUNTIME1") @njit def edit_it(b): b.B += 1 print("RUNTIME2") edit_it(b1) edit_it(b2) # edit_it.py_func(b2) print("RUNTIME3") @njit def declare_it(kb, b, name): kb.declare(b, name) print("RUNTIME3.1", b1.fact_num) declare_it(kb, b1, "b1") print("RUNTIME3.2") declare_it.py_func(kb, b2, "b2") print("RUNTIMEz") with pytest.raises(AttributeError): print("RUNTIME_PY") edit_it.py_func(b1) with pytest.raises(AttributeError): print("RUNTIME_PY") edit_it.py_func(b2) with pytest.raises(AttributeError): print("RUNTIME_NB", b1.B) edit_it(b1) with pytest.raises(AttributeError): print("RUNTIME_NB", b1.B) edit_it(b1)
def get_beta_predicate_node_definition(left_fact_type, left_attr_chain, op_str, right_fact_type, right_attr_chain): '''Gets various definitions for an BetaPredicateNode, returns a dict with 'ctor' 'pnode_type', 'left_type', 'left_attr_offsets', 'left_t_id', 'right_type', 'right_attr_offsets', 'right_t_id' ''' context = kb_context() left_t_id = context.fact_to_t_id[left_fact_type._fact_name] right_t_id = context.fact_to_t_id[right_fact_type._fact_name] if(not isinstance(left_attr_chain,list)): attr_chain = [left_attr_chain] if(not isinstance(right_attr_chain,list)): attr_chain = [right_attr_chain] left_type, left_attr_offsets = resolve_deref(left_fact_type, left_attr_chain) right_type, right_attr_offsets = resolve_deref(right_fact_type, right_attr_chain) ctor, pnode_type = define_beta_predicate_node(left_type, op_str, right_type) return locals()
def _fact_from_fields(name, fields, context=None): context = kb_context(context) hash_code = unique_hash([name,fields]) if(not source_in_cache(name,hash_code)): fact_num = lines_in_fact_registry() source = gen_fact_code(name,fields,fact_num) source_to_cache(name, hash_code, source) add_to_fact_registry(name, hash_code) fact_ctor, fact_type = import_from_cached(name, hash_code,[name,name+"Type"]).values() fact_ctor._hash_code = hash_code fact_type._hash_code = hash_code # fact_type = fact_type_template(fields=fields) # print("fact_type",fact_type) return fact_ctor, fact_type
def test_modify(): with kb_context("test_modify"): TextField, TextFieldType = define_fact("TextField", tf_spec) kb = KnowledgeBase() fact = TextField("A", "B", "C", "D", "E") modify_right(kb, fact, "nb") assert fact.to_right == "nb" modify_right.py_func(kb, fact, "py") assert fact.to_right == "py" with pytest.raises(TypingError): bad_modify_type(kb) with pytest.raises(TypingError): bad_modify_type.py_func(kb)
def test_grow_change_queues(): with kb_context("test_grow_change_queues"): TextField, TextFieldType = define_fact("TextField", tf_spec) #NRT version kb = KnowledgeBase() dummy_subscriber = dummy_subscriber_ctor() kb.add_subscriber(dummy_subscriber) idrec = kb.declare(TextField("A", "B", "C", "D", "E")) # assert kb.kb_data.subscribers[0].grow_queue.data[0] == idrec gr_q = kb.kb_data.grow_queue assert gr_q.data[gr_q.head - 1] == idrec kb.retract(idrec) # assert kb.kb_data.subscribers[0].change_queue.data[0] == idrec ch_q = kb.kb_data.change_queue assert ch_q.data[ch_q.head - 1] == idrec
def test__merge_spec_inheritance(): context = kb_context("test__merge_spec_inheritance") spec1 = {"A": "string", "B": "number"} BOOP, BOOPType = define_fact("BOOP", spec1, context="test__merge_spec_inheritance") #Should be able to inherit from ctor, type or type string spec2 = {"inherit_from": BOOP, "C": "number"} spec_out, inherit_from = _merge_spec_inheritance(spec2, context) assert inherit_from._fact_name == "BOOP" assert "inherit_from" not in spec_out spec2 = {"inherit_from": BOOPType, "C": "number"} spec_out, inherit_from = _merge_spec_inheritance(spec2, context) assert inherit_from._fact_name == "BOOP" assert "inherit_from" not in spec_out spec2 = {"inherit_from": "BOOP", "C": "number"} spec_out, inherit_from = _merge_spec_inheritance(spec2, context) assert inherit_from._fact_name == "BOOP" assert "inherit_from" not in spec_out assert "A" in spec_out assert "B" in spec_out #It is illegal to redefine an attribute to have a new type with pytest.raises(TypeError): spec2 = _standardize_spec({ "inherit_from": "BOOP", "B": "string", "C": "string" }) spec_out, inherit_from = _merge_spec_inheritance(spec2, context) #But okay to to redefine an attribute if the types match spec2 = _standardize_spec({ "inherit_from": "BOOP", "B": "number", "C": "string" }) spec_out, inherit_from = _merge_spec_inheritance(spec2, context)
def define_fact(name : str, spec : dict, context=None): '''Defines a new fact.''' context = kb_context(context) spec = _standardize_spec(spec) spec, inherit_from = _merge_spec_inheritance(spec,context) if(name in context.fact_types): assert context.fact_types[name].spec != spec, \ f"Redefinition of fact '{name}' in context '{context.name}' not permitted" fact_ctor, fact_type = _fact_from_spec(name, spec, context=context) context._assert_flags(name,spec) # print("PASSING IN", inherit_from) context._register_fact_type(name,spec,fact_ctor,fact_type,inherit_from=inherit_from) # fact_ctor.name = fact_type.name = name fact_ctor.spec = fact_type.spec = spec return fact_ctor, fact_type
def test_link(): with kb_context() as context: print(context.fact_types) # BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) l1, l2 = Var(BOOPType, "l1"), Var(BOOPType, "l2") r1, r2 = Var(BOOPType, "r1"), Var(BOOPType, "r2") c = (l1.B < 1) & (l1.B > 7) & (l2.B < r1.B) & (r2.B < l1.B) |\ (l2.B < 1) & (l2.B > 7) & (l2.B < r1.B) & (r1.B < r2.B) |\ (l2.B < 1) & (l2.B > 7) & (l2.B < r1.B) & (l1.B < l2.B) kb = KnowledgeBase() cl = get_linked_conditions_instance(c, kb) assert get_pointer(cl) == get_pointer(c) cl = get_linked_conditions_instance(c, kb, copy=True) assert get_pointer(cl) != get_pointer(c)
def cast_fact(typ, val): '''Casts a fact to a new type of fact if possible''' context = kb_context() inst_type = typ.instance_type # print("CAST", val._fact_name, "to", inst_type._fact_name) #Check if the fact_type can be casted if(inst_type._fact_name != "BaseFact" and val._fact_name != "BaseFact" and inst_type._fact_name not in context.children_of[val._fact_name] and inst_type._fact_name not in context.parents_of[val._fact_name] ): error_message = f"Cannot cast fact of type '{val._fact_name}' to '{inst_type._fact_name}.'" #If it shouldn't be possible then throw an error def error(typ,val): raise TypeError(error_message) return error def impl(typ,val): return _cast_structref(inst_type,val) return impl
def test_initialize(): with kb_context("test_initialize"): # BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) l1, l2 = Var(BOOPType, "l1"), Var(BOOPType, "l2") r1, r2 = Var(BOOPType, "r1"), Var(BOOPType, "r2") c = (l1.B < 1) & (l1.B > 7) & (l2.B < r1.B) & (r2.B < l1.B) |\ (l2.B < 1) & (l2.B > 7) & (l2.B < r1.B) & (r1.B < r2.B) |\ (l2.B < 1) & (l2.B > 7) & (l2.B < r1.B) & (l1.B < l2.B) assert [x.alias for x in cond_get_vars(c)] == ['l1', 'l2', 'r1', 'r2'] initialize_conditions(c) print("DONE") alpha_sizes, beta_sizes = get_init_cond_sizes(c) print(alpha_sizes) print(beta_sizes) assert [list(x) for x in alpha_sizes] == [[2, 0, 0, 0], [0, 2, 0, 0], [0, 2, 0, 0]] assert [list(x) for x in beta_sizes] == [[1, 1], [1, 1], [1, 1]]
def test_declare_retract(): with kb_context("test_declare_retract"): #NRT version kb = KnowledgeBase() assert declare_retract(kb) == 10 assert declare_again(kb) == 0 #Python version kb = KnowledgeBase() assert declare_retract.py_func(kb) == 10 assert declare_again.py_func(kb) == 0 with pytest.raises(TypingError): bad_declare_type(kb) with pytest.raises(TypingError): bad_declare_type.py_func(kb) with pytest.raises(TypingError): bad_retract_type(kb) with pytest.raises(TypingError): bad_retract_type.py_func(kb)
def test_cast_fact(): with kb_context("test_cast_fact") as context: spec1 = {"A": "string", "B": "number"} BOOP1, BOOP1Type = define_fact("BOOP1", spec1, context="test_cast_fact") spec2 = {"inherit_from": BOOP1, "C": "number"} BOOP2, BOOP2Type = define_fact("BOOP2", spec2, context="test_cast_fact") spec3 = {"inherit_from": BOOP2, "D": "number"} BOOP3, BOOP3Type = define_fact("BOOP3", spec3, context="test_cast_fact") b1 = BOOP1("A", 7) b3 = BOOP3("A", 1, 2, 3) bs = BaseFact() #Downcast @njit def down_cast(b): return cast_fact(BOOP1Type, b) _b1 = down_cast(b3) assert type(b1) == type(_b1) _b1 = down_cast.py_func(b3) assert type(b1) == type(_b1) #Upcast back @njit def up_cast(b): return cast_fact(BOOP3Type, b) _b3 = up_cast(_b1) assert type(b3) == type(_b3) _b3 = up_cast.py_func(_b1) assert type(b3) == type(_b3) FLOOP, FLOOPType = define_fact("FLOOP", spec3, context="test_cast_fact") #Bad cast @njit def bad_cast(b): return cast_fact(FLOOPType, b) with pytest.raises(TypeError): bad_cast(b3) with pytest.raises(TypeError): bad_cast.py_func(b3) #Always allow casting to and from BaseFact @njit def base_down_cast(b): return cast_fact(BaseFactType, b) _bs = base_down_cast(_b1) assert type(bs) == type(_bs) _bs = base_down_cast.py_func(_b1) assert type(bs) == type(_bs) @njit def base_up_cast(b): return cast_fact(BOOP1Type, b) _b1 = base_up_cast(_bs) assert type(b1) == type(_b1) _b1 = base_up_cast.py_func(_bs) assert type(b1) == type(_b1)
def test_alpha_predicate_node(): with kb_context("test_alpha_predicate_node"): BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) kb = KnowledgeBase() pn = get_alpha_predicate_node(BOOPType,"B", "<",9) ld = generate_link_data(pn, kb) # kb.add_subscriber(pn) x = BOOP("x",7) y = BOOP("y",11) z = BOOP("z",8) assert len(ld.truth_values) == 0 kb.declare(x) kb.declare(y) kb.declare(z) # njit_update(pn) inds = filter_alpha(pn, ld, np.arange(3)) assert np.array_equal(inds, [0,2]) assert all(ld.truth_values[:3,0] == [1,0,1]) kb.modify(x,"B", 100) kb.modify(y,"B", 3) kb.modify(z,"B", 88) #Checks doesn't change before update assert all(ld.truth_values[:3,0] == [1,0,1]) inds = filter_alpha(pn, ld, np.arange(3)) assert np.array_equal(inds, [1]) assert all(ld.truth_values[:3,0] == [0,1,0]) kb.retract(x) kb.retract(y) kb.retract(z) #Checks doesn't change before update assert all(ld.truth_values[:3,0] == [0,1,0]) inds = filter_alpha(pn, ld, np.arange(3)) print(inds) assert np.array_equal(inds, []) # print(ld.truth_values) #Checks that retracted facts show up as u1.nan = 0XFF assert all(ld.truth_values[:3,0] == [0xFF,0xFF,0xFF]) kb.declare(x) kb.declare(y) kb.declare(z) kb.modify(z,"A","Z") kb.modify(x,"B",0) kb.modify(y,"B",0) kb.modify(z,"B",0) inds = filter_alpha(pn, ld, np.arange(3)) assert np.array_equal(inds, [0,1,2]) assert all(ld.truth_values[:3,0] == [1,1,1])
import pytest from collections import namedtuple from cre.subscriber import BaseSubscriberType, init_base_subscriber from cre.utils import _struct_from_meminfo tf_spec = { "value": "string", "above": "string", "below": "string", "to_left": "string", "to_right": "string", } ##### test_declare_retract ##### with kb_context("test_declare_retract"): TextField, TextFieldType = define_fact("TextField", tf_spec) @njit(cache=True) def declare_retract(kb): for i in range(100): i_s = "A" + str(i) kb.declare(TextField(i_s, i_s, i_s, i_s, i_s), i_s) for i in range(0, 100, 10): i_s = "A" + str(i) kb.retract(i_s) # print(kb.kb_data.empty_f_id_heads) t_id = kb.context_data.fact_to_t_id["TextField"]
def test_declare_overloading(): with kb_context("test_declare_overloading"): kb = KnowledgeBase() idrec1 = declare_unnamed(kb) idrec2 = declare_unnamed.py_func(kb) assert idrec1 != idrec2
def test_build_conditions(): with kb_context("test_build_conditions"): # BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) l1, l2 = Var(BOOPType, "l1"), Var(BOOPType, "l2") r1, r2 = Var(BOOPType, "r1"), Var(BOOPType, "r2") c1 = l1.B < 1 c2 = l1.B < l2.B assert str(c1) == "(l1.B < ?)" assert str(c2) == "(l1.B < l2.B)" ### LT + AND/OR ### c3 = (l1.B < 1) & (l1.B > 7) & (l1.B < r1.B) & (l1.B < r2.B) |\ (l2.B < 1) & (l2.B > 7) & (l2.B < r1.B) & (l2.B < r2.B) c3_str = \ '''(l1.B < ?) & (l1.B > ?) & (l1.B < r1.B) & (l1.B < r2.B) |\\ (l2.B < ?) & (l2.B > ?) & (l2.B < r1.B) & (l2.B < r2.B)''' assert str(c3) == c3_str ### NOT ### nc3_str = \ '''~(l1.B < ?) & ~(l2.B < ?) |\\ ~(l1.B < ?) & ~(l2.B > ?) |\\ ~(l1.B < ?) & ~(l2.B < r1.B) |\\ ~(l1.B < ?) & ~(l2.B < r2.B) |\\ ~(l1.B > ?) & ~(l2.B < ?) |\\ ~(l1.B > ?) & ~(l2.B > ?) |\\ ~(l1.B > ?) & ~(l2.B < r1.B) |\\ ~(l1.B > ?) & ~(l2.B < r2.B) |\\ ~(l2.B < ?) & ~(l1.B < r1.B) |\\ ~(l2.B > ?) & ~(l1.B < r1.B) |\\ ~(l1.B < r1.B) & ~(l2.B < r1.B) |\\ ~(l1.B < r1.B) & ~(l2.B < r2.B) |\\ ~(l2.B < ?) & ~(l1.B < r2.B) |\\ ~(l2.B > ?) & ~(l1.B < r2.B) |\\ ~(l1.B < r2.B) & ~(l2.B < r1.B) |\\ ~(l1.B < r2.B) & ~(l2.B < r2.B)''' assert str(~c3) == nc3_str ### EQ / NEQ ### c4 = (l1.B == 5) & (l1.B == 5) & (l1.B == l2.B) & (l1.B != l2.B) c4_str = \ '''(l1.B == ?) & (l1.B == ?) & (l1.B == l2.B) & ~(l1.B == l2.B)''' assert str(c4) == c4_str nc4_str = \ '''~(l1.B == ?) |\\ ~(l1.B == ?) |\\ ~(l1.B == l2.B) |\\ (l1.B == l2.B)''' assert str(~c4) == nc4_str ### AND / OR btw DNFS ### c3_and_c4_str = \ '''(l1.B < ?) & (l1.B > ?) & (l1.B == ?) & (l1.B == ?) & (l1.B < r1.B) & (l1.B < r2.B) & (l1.B == l2.B) & ~(l1.B == l2.B) |\\ (l2.B < ?) & (l2.B > ?) & (l1.B == ?) & (l1.B == ?) & (l2.B < r1.B) & (l2.B < r2.B) & (l1.B == l2.B) & ~(l1.B == l2.B)''' assert str(c3 & c4) == c3_and_c4_str c3_or_c4_str = \ '''(l1.B < ?) & (l1.B > ?) & (l1.B < r1.B) & (l1.B < r2.B) |\\ (l2.B < ?) & (l2.B > ?) & (l2.B < r1.B) & (l2.B < r2.B) |\\ (l1.B == ?) & (l1.B == ?) & (l1.B == l2.B) & ~(l1.B == l2.B)''' assert str(c3 | c4) == c3_or_c4_str
def _benchmark_setup(): with kb_context("test_kb"): kb = KnowledgeBase() return (kb, ), {}
def _get_alpha_predicate_node(): with kb_context("test_predicate_node"): pn = get_alpha_predicate_node(BOOPType,"B", "<",50) pn = get_alpha_predicate_node(BOOPType,"B", "<",49)
def test_beta_predicate_node_2_typed(): with kb_context("test_beta_predicate_node_2_typed"): BOOP1, BOOP1Type = define_fact("BOOP1",{"A": "number", "B" : "string"}) BOOP2, BOOP2Type = define_fact("BOOP2",{"A": "string", "B" : "number"}) kb = KnowledgeBase() pn = get_beta_predicate_node(BOOP1Type,"A", "<", BOOP2Type,"B") ld = generate_link_data(pn, kb) # kb.add_subscriber(pn) x1,x2 = BOOP1(7,"x"), BOOP2("x",7.5) #<- slightly different y1,y2 = BOOP1(11,"y"), BOOP2("y",11) z1,z2 = BOOP1(8,"z"), BOOP2("z",8) assert len(ld.truth_values) == 0 kb.declare(x1); kb.declare(x2) kb.declare(y1); kb.declare(y2) kb.declare(z1); kb.declare(z2) inds = filter_beta(pn, ld, np.arange(3), np.arange(3)) # print(inds) # print(ld.truth_values) assert np.array_equal(inds, [[0,0],[0, 1], [0, 2], [2, 1]]) assert all(ld.truth_values[0,:3] == [1,1,1]) assert all(ld.truth_values[1,:3] == [0,0,0]) assert all(ld.truth_values[2,:3] == [0,1,0]) q1, q2 = BOOP1(-7,"q"), BOOP2("q",-7) r1, r2 = BOOP1(-11,"r"), BOOP2("r",-11) t1, t2 = BOOP1(-8,"t"), BOOP2("t",-8) kb.declare(q1); kb.declare(q2) kb.declare(r1); kb.declare(r2) kb.declare(t1); kb.declare(t2) inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # print(inds) # print(ld.truth_values[:6,:6]) assert np.array_equal(inds,[[0,0],[0,1],[0,2],[2,1],[3,0],[3,1], [3,2],[4,0],[4,1],[4,2],[4,3],[4,5],[5,0],[5,1],[5,2],[5,3]]) assert all(ld.truth_values[0,:6] == [1,1,1,0,0,0]) assert all(ld.truth_values[1,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[2,:6] == [0,1,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,1,1,0,0,0]) assert all(ld.truth_values[4,:6] == [1,1,1,1,0,1]) assert all(ld.truth_values[5,:6] == [1,1,1,1,0,0]) kb.modify(r1,"A", 0); kb.modify(r2,"B", 0) kb.modify(y1,"A", 0); kb.modify(y2,"B", 0) inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # print(ld.truth_values[:6,:6]) assert all(ld.truth_values[0,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[1,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[2,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,1,1,0,1,0]) assert all(ld.truth_values[4,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[5,:6] == [1,1,1,1,1,0]) kb.retract(r1); kb.retract(r2) kb.retract(y1); kb.retract(y2) inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # print(ld.truth_values[:6,:6]) assert all(ld.truth_values[0,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[1,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[2,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[4,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[5,:6] == [1,0,1,1,0,0])
def test_beta_predicate_node_1_typed(): with kb_context("test_beta_predicate_node_1_typed"): BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) kb = KnowledgeBase() pn = get_beta_predicate_node(BOOPType,"B", "<", BOOPType,"B") # png = cast(pn, GenericBetaPredicateNodeType) ld = generate_link_data(pn, kb) # kb.add_subscriber(pn) x = BOOP("x",7) y = BOOP("y",11) z = BOOP("z",8) assert len(ld.truth_values) == 0 kb.declare(x) kb.declare(y) kb.declare(z) # njit_update(pn) inds = filter_beta(pn, ld, np.arange(3), np.arange(3)) # print("B") # print(inds) assert np.array_equal(inds, [[0, 1], [0, 2], [2, 1]]) # print(ld.truth_values) assert all(ld.truth_values[0,:3] == [0,1,1]) assert all(ld.truth_values[1,:3] == [0,0,0]) assert all(ld.truth_values[2,:3] == [0,1,0]) q = BOOP("q",-7) r = BOOP("r",-11) t = BOOP("t",-8) kb.declare(q) kb.declare(r) kb.declare(t) inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # print(inds) assert np.array_equal(inds,[[0,1],[0,2],[2,1],[3,0],[3,1], [3,2],[4,0],[4,1],[4,2],[4,3],[4,5],[5,0],[5,1],[5,2],[5,3]]) # njit_update(pn) # print(ld.truth_values[:6,:6]) assert all(ld.truth_values[0,:6] == [0,1,1,0,0,0]) assert all(ld.truth_values[1,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[2,:6] == [0,1,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,1,1,0,0,0]) assert all(ld.truth_values[4,:6] == [1,1,1,1,0,1]) assert all(ld.truth_values[5,:6] == [1,1,1,1,0,0]) kb.modify(r,"B", 0) kb.modify(y,"B", 0) inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # njit_update(pn) # print(ld.truth_values[:6,:6]) assert all(ld.truth_values[0,:6] == [0,0,1,0,0,0]) assert all(ld.truth_values[1,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[2,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,1,1,0,1,0]) assert all(ld.truth_values[4,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[5,:6] == [1,1,1,1,1,0]) kb.retract(r) kb.retract(y) inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # njit_update(pn) # print(ld.truth_values[:6,:6]) assert all(ld.truth_values[0,:6] == [0,0,1,0,0,0]) assert all(ld.truth_values[1,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[2,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[4,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[5,:6] == [1,0,1,1,0,0])
inds = filter_beta(pn, ld, np.arange(6), np.arange(6)) # print(ld.truth_values[:6,:6]) assert all(ld.truth_values[0,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[1,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[2,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[3,:6] == [1,0,1,0,0,0]) assert all(ld.truth_values[4,:6] == [0,0,0,0,0,0]) assert all(ld.truth_values[5,:6] == [1,0,1,1,0,0]) # import time with kb_context("test_predicate_node"): BOOP, BOOPType = define_fact("BOOP",{"A": "string", "B" : "number"}) #### get_alpha_predicate_node #### def _get_alpha_predicate_node(): with kb_context("test_predicate_node"): pn = get_alpha_predicate_node(BOOPType,"B", "<",50) pn = get_alpha_predicate_node(BOOPType,"B", "<",49) @pytest.mark.benchmark(group="setup") def test_b_get_alpha_predicate_node(benchmark): benchmark.pedantic(_get_alpha_predicate_node, iterations=1) #### setup ####