def test_rule_if_clause_condition_if_clause_with_and(self):
fcl_text = """
FUNCTION_BLOCK f_block
RULEBLOCK rule1
RULE first_rule : IF something AND otherthing THEN conclusion IS final;
END_RULEBLOCK
END_FUNCTION_BLOCK
"""
class FclListenerRules(FclListener):
def enterIf_clause(_self, ctx):
condition = ctx.condition()
something = condition.getChild(0).getText()
operator = condition.getChild(1).getText()
otherthing = condition.getChild(2).getText()
self.assertEqual(something, 'something')
self.assertEqual(operator, 'AND')
self.assertEqual(otherthing, 'otherthing')
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerRules()
walker = ParseTreeWalker()
walker.walk(listener, tree)
def test_rule_if_clause_condition_then_clause_with_x(self):
fcl_text = """
FUNCTION_BLOCK f_block
RULEBLOCK rule1
RULE first_rule : IF something AND otherthing THEN final IS final2 WITH 123;
END_RULEBLOCK
END_FUNCTION_BLOCK
"""
class FclListenerRules(FclListener):
def enterThen_clause(_self, ctx):
conclusion = ctx.conclusion()
subconclusion = conclusion.sub_conclusion()[0]
final = subconclusion.ID()[0].getText()
final2 = subconclusion.ID()[1].getText()
self.assertEqual(final, 'final')
self.assertEqual(final2, 'final2')
def enterWith_x(_self, ctx):
real = ctx.REAL().getText()
self.assertEqual(real, '123')
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerRules()
walker = ParseTreeWalker()
walker.walk(listener, tree)
def test_consequent_define_universe_override_range_defined_in_var_if_defined_in_consequent(self):
fcl_text = """
FUNCTION_BLOCK my_system
VAR_output
consequent1 : REAL (1 .. 9);
END_VAR
DEFUZZIFY consequent1
RANGE := (0 .. 30);
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
consequents = listener.consequents
expected_universe = np.asarray([0., 30.])
self.assertIn('consequent1', consequents)
self.assertEqual('consequent1', consequents.get('consequent1').get('value').label)
np.testing.assert_array_equal(expected_universe, consequents.get('consequent1').get('value').universe)
def test_antecedents_terms_have_correct_mf_values_using_singleton_and_piecewise(self):
fcl_text = """
FUNCTION_BLOCK my_system
FUZZIFY antecedent1
TERM mf1 := 4.0;
TERM mf2 := (0, 0.2) (2, 0) (3, 1);
TERM mf3 := 1.0;
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
antecedent = listener.antecedents.get('antecedent1').get('value')
term = antecedent['mf1']
expected_mf_value = np.asarray([0, 0, 0, 0, 1]) # fx[0], fx[1], fx[2], fx[3], f[4]
np.testing.assert_array_equal(expected_mf_value, term.mf)
term = antecedent['mf2']
expected_mf_value = np.asarray([0.2, 0.1, 0, 1, 0]) # fx[0], fx[1], fx[2], fx[3], f[4]
np.testing.assert_array_equal(expected_mf_value, term.mf)
term = antecedent['mf3']
expected_mf_value = np.asarray([0, 1, 0, 0, 0]) # fx[0], fx[1], fx[2], fx[3], f[4]
np.testing.assert_array_equal(expected_mf_value, term.mf)
def test_var_input_and_output(self):
fcl_text = """
FUNCTION_BLOCK f_block
VAR_INPUT
input_id1 : REAL;
END_VAR
VAR_OUTPUT
output_id1 : REAL;
END_VAR
VAR_INPUT
input_id2 : REAL;
END_VAR
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual(['output_id1', 'REAL'], listener.outputs[0])
self.assertEqual(['input_id1', 'REAL'], listener.inputs[0])
self.assertEqual(['input_id2', 'REAL'], listener.inputs[1])
def test_antecedents_terms_have_correct_mf_values_with_more_then_one_term(self):
fcl_text = """
FUNCTION_BLOCK my_system
FUZZIFY antecedent1
TERM mf1 := (0, 1) (0.5, 0);
TERM mf2 := (1, 0.3) (2, 0) (3, 1);
TERM mf3 := (2, 0.4) (4, 1) (5, 1);
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
antecedent = listener.antecedents.get('antecedent1').get('value')
term = antecedent['mf1']
expected_mf_value = np.asarray([1, 0, 0, 0, 0, 0, 0])
np.testing.assert_array_equal(expected_mf_value, term.mf)
term2 = antecedent['mf2']
expected_mf_value = np.asarray([0, 0, 0.3, 0, 1, 0, 0])
np.testing.assert_array_equal(expected_mf_value, term2.mf)
term3 = antecedent['mf3']
expected_mf_value = np.asarray([0, 0, 0, 0.4, 0.7, 1, 1])
np.testing.assert_array_equal(expected_mf_value, term3.mf)
def test_should_raise_parser_exception_if_incorrect_fcl_text(self):
fcl_text = "INCORRECT FCL TEXT"
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
with self.assertRaises(FclParserException):
walker.walk(listener, tree)
def test_load_simple_function_block2(self):
fcl_text = """
FUNCTION_BLOCK
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual([], listener.function_blocks_ids)
def test_should_create_empyt_control_system_if_no_declaration(self):
fcl_text = """
FUNCTION_BLOCK my_system
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
control_system = listener.control_system
self.assertIsNot(control_system, None)
def test_rule_block(self):
fcl_text = """
FUNCTION_BLOCK f_block
RULEBLOCK rule1
END_RULEBLOCK
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual('rule1', listener.last_rule_block.get('id'))
def test_defuzzify_block_with_defuzzification_method(self):
fcl_text = """
FUNCTION_BLOCK f_block
DEFUZZIFY defuzz_id
METHOD : COG;
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual('COG', listener.last_deffuz_method)
def test_singletons(self):
fcl_text = """
FUNCTION_BLOCK f_block
FUZZIFY fuzzyfy_id
TERM sing := SINGLETONS (0, 1) (1, 2);
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual([['0', '1'], ['1', '2']], listener.last_singletons)
def test_piece_wise_linear(self):
fcl_text = """
FUNCTION_BLOCK f_block
FUZZIFY fuzzyfy_id
TERM term1 := (0, 1);
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual([['0', '1']], listener.last_piece_wise_liner)
def test_var_inputs_if_var_input_empty(self):
fcl_text = """
FUNCTION_BLOCK my_system
VAR_INPUT
END_VAR
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
loaded_vars = listener.vars
self.assertEqual(loaded_vars, {})
def test_var_input_range(self):
fcl_text = """
FUNCTION_BLOCK f_block
VAR_INPUT
input_id : REAL ( 12 .. 34 );
END_VAR
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual(['input_id', 'REAL', '12', '34'], listener.inputs[0])
def test_defuzzify_block_with_default_value_nc(self):
fcl_text = """
FUNCTION_BLOCK f_block
DEFUZZIFY defuzz_id
DEFAULT := NC;
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual('defuzz_id', listener.last_defuzz.get('id'))
self.assertEqual('NC', listener.last_default_value)
def test_antecedents_created_when_fuzzify_block_described(self):
fcl_text = """
FUNCTION_BLOCK my_system
FUZZIFY antecedent1
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
antecedents = listener.antecedents
self.assertIn('antecedent1', antecedents)
self.assertEqual('antecedent1', antecedents.get('antecedent1').get('value').label)
def test_tipper_fcl_file(self):
fcl_text = ""
fcl_file_path = FIXTURES_DIR.child('tipper.fcl')
with open(fcl_file_path, 'r') as fcl_file:
fcl_text = fcl_file.read()
class FclListenerNoError(FclListener):
def visitErrorNode(self, node):
raise FclParserException(node)
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerNoError()
walker = ParseTreeWalker()
walker.walk(listener, tree)
def test_add_vars_if_var_input_simple(self):
fcl_text = """
FUNCTION_BLOCK my_system
VAR_INPUT
var1 : REAL;
END_VAR
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
loaded_vars = listener.vars
self.assertEqual(loaded_vars, {'var1': {'type': 'REAL', 'range': None}})
def test_linguistic_term(self):
fcl_text = """
FUNCTION_BLOCK f_block
FUZZIFY fuzzyfy_id
TERM term1 := mf ;
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
fb = listener.fuzzyfy_blocks[0]
ling_term = fb.get('linguistic_term')[0]
self.assertEqual('term1', ling_term.get('id'))
def test_rule(self):
fcl_text = """
FUNCTION_BLOCK f_block
RULEBLOCK rule1
RULE first_rule : IF something THEN finalthing IS conclusion;
RULE 2 : IF something THEN finalthing IS conclusion;
END_RULEBLOCK
END_FUNCTION_BLOCK
"""
# RULE first_rule : IF something IS otherthing OR something2 IS otherthing2 THEN finalthing IS conclusion;
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual('first_rule', listener.rules[0].get('id'))
self.assertEqual('2', listener.rules[1].get('id'))
def test_defuzzify_block_with_range(self):
fcl_text = """
FUNCTION_BLOCK f_block
DEFUZZIFY defuzz_id
RANGE := ( 12 .. 34 );
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual('defuzz_id', listener.last_defuzz.get('id'))
self.assertEqual(['RANGE:=(12..34);'],
listener.last_defuzz.get('items'))
def test_antecedents_universe_has_correct_value_based_on_term(self):
fcl_text = """
FUNCTION_BLOCK my_system
FUZZIFY antecedent1
TERM mf1 := (0, 1) (0.5, 0);
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
antecedent = listener.antecedents.get('antecedent1').get('value')
expected_universe = np.asarray([0, 0.5])
np.testing.assert_array_equal(expected_universe, antecedent.universe)
def test_consequents_defuzzify_method_mom_as_mom(self):
fcl_text = """
FUNCTION_BLOCK my_system
DEFUZZIFY consequent1
METHOD : MOM;
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
consequents = listener.consequents
self.assertIn('consequent1', consequents)
self.assertEqual('consequent1', consequents.get('consequent1').get('value').label)
self.assertEqual('mom', consequents.get('consequent1').get('value').defuzzify_method)
def test_antecedents_terms_have_correct_mf_values_using_singleton(self):
fcl_text = """
FUNCTION_BLOCK my_system
FUZZIFY antecedent1
TERM mf1 := 1.0;
END_FUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
antecedent = listener.antecedents.get('antecedent1').get('value')
term = antecedent['mf1']
expected_mf_value = np.asarray([1])
np.testing.assert_array_equal(expected_mf_value, term.mf)
def test_consequents_term_defined_if_present(self):
fcl_text = """
FUNCTION_BLOCK my_system
DEFUZZIFY consequent1
TERM mf1 := (0, 1) (1, 1);
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = ScikitFuzzyFclListener()
walker = ParseTreeWalker()
walker.walk(listener, tree)
consequents = listener.consequents
self.assertIn('consequent1', consequents)
self.assertEqual('consequent1', consequents.get('consequent1').get('value').label)
self.assertIn('mf1', consequents.get('consequent1').get('value').terms)
self.assertIn('mf1', consequents.get('consequent1').get('value').terms.get('mf1').label)
def test_defuzzify_block_with_linguistic_term(self):
fcl_text = """
FUNCTION_BLOCK f_block
DEFUZZIFY defuzz_id
TERM term1 := (0,0) (5,1) (10,0);
TERM term2 := (1,2);
END_DEFUZZIFY
END_FUNCTION_BLOCK
"""
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerTester()
walker = ParseTreeWalker()
walker.walk(listener, tree)
self.assertEqual('defuzz_id', listener.last_defuzz.get('id'))
self.assertEqual('term1', listener.last_linguistic_terms[0].get('id'))
self.assertEqual([['1', '2']], listener.last_piece_wise_liner)
self.assertEqual('term2', listener.last_linguistic_terms[1].get('id'))
def test_if_clause_complex(self):
fcl_text = """
FUNCTION_BLOCK f_block
RULEBLOCK rule1
RULE first_rule : IF (something IS NOT otherthing) THEN final IS final2;
END_RULEBLOCK
END_FUNCTION_BLOCK
"""
class FclListenerRules(FclListener):
def enterSubcondition_paren(_self, ctx):
condition = ctx.condition().getText()
self.assertEqual(condition, 'somethingISNOTotherthing')
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerRules()
walker = ParseTreeWalker()
walker.walk(listener, tree)
def test_mf_cosine(self):
fcl_text = """
FUNCTION_BLOCK f_block
FUZZIFY service
TERM mf := COSINE 123 345;
END_FUZZIFY
END_FUNCTION_BLOCK
"""
class FclListenerRules(FclListener):
def enterCosine(_self, ctx):
cosine_args = [arg.getText() for arg in ctx.atom()]
self.assertEqual(cosine_args, ['123', '345'])
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerRules()
walker = ParseTreeWalker()
walker.walk(listener, tree)
def test_mf_gbell(self):
fcl_text = """
FUNCTION_BLOCK f_block
FUZZIFY service
TERM mf := GBELL a b c;
END_FUZZIFY
END_FUNCTION_BLOCK
"""
class FclListenerRules(FclListener):
def enterGbell(_self, ctx):
args = [arg.getText() for arg in ctx.atom()]
self.assertEqual(args, ['a', 'b', 'c'])
lexer = FclLexer(InputStream(fcl_text))
stream = CommonTokenStream(lexer)
parser = FclParser(stream)
tree = parser.main()
listener = FclListenerRules()
walker = ParseTreeWalker()
walker.walk(listener, tree)