Fuzzy Theory

1. Allocation of a linguistic variable

LinguisticVariable angle = Factory.makeLinguisticVariable("angle");

The String argument is the name/label of this particular linguistic variable in the rules

2. Definition of membership functions

angle.add("negative", -3.14, -3.14, 0.0314, 0);

"Negative" here is the name that will be used to address this membership function (if angle is negative ...), other four parameters define four key points of a trapezoid. They follow in the order of left bottom, left top, right top and right bottom points.

A text label assigned to a rule. A rule's default weight is 1.0. The weight can be changed by executing expression of the form
"rule label weight is weightMF"
in the right part of a rule. The same label can be assigned to more than one rule. In this case weight change will affect all of the labeled rules.

Example: start: if angle is ...

A service word indicating the beginning of the left part (evaluation part) of a fuzzy rule.

A linguistic variable. Linguistic variables are addressed by their names. Each linguistic variable has one or more associated membership functions.

A service word separating linguistic variable and hedges/membership function.

The engine has 3 predefined hedges: "not", "very" and "somewhat". The user can define arbitrary hedges and use them in rules.

Example: if weather is not very nice ...

A membership function. Membership functions are addressed by their names. Each membership function is defined as a trapezoid.

Service words indicating logical operation to be performed on the neighboring fuzzy expressions. Priority of the and/or operations decreases from left to right and may be changed by applying parenthesis. The engine supports arbitrary number of expressions on the left part, arbitrary nesting and and/or operations.

Example: if angle is wide or (angle is normal and (speed is high or speed is normal)) ...

A service word separating left part of expression from the right part (execution part). Result obtained from evaluation of the left part is used to perform fuzzy assignments in the right part. The form of fuzzy expressions is the same as in the evaluation part, except assignment is performed instead of evaluation. During the assignment, hedges apply to the result of evaluation part. Application of the hedges is local for each fuzzy expression. If more than one assignment is to be performed, then fuzzy expression should separated by the service word "and" .

Example: ... then power is very low and steering is toTheLeft

This is a reserved linguistic variable. Linguistic variable "weight" is defined by the user and serves for the purpose of changing a rule's weight. A copy of this LV is created for each unique label. Changes of weight are performed by defuzzification of the copy assigned to a particular label, thus multiple weight changes are carried out in fuzzy manner. How much a rule's weight will be changed depends both on definition of membership functions for "weight", evaluation result after application of hedges and number of assignments.

Example:

LinguisticVariable weight= Factory.makeLinguisticVariable("weight");
weight.add("low",0,0,0.2,0.3);
...
fuzzyEngine.evaluateRule("start: if angle is wide then rule start: weight is low");

When weight assignment is performed on the same rule that assigns the weight (see Example) then only one iteration of weight change is performed, i.e. it does not fall into an endless loop of weight change.

A service word for unconditional assignments. If "set" is encountered instead of "if", result of the left part evaluation is assumed to be 1.0 and all assignments are performed for that value.

Example: set power is low ...

1. Create linguistic variables and define membership functions

Factory factory = Factory.getFactory();

LinguisticVariable angle = factory.makeLinguisticVariable("angle");

angle.add("negative",-3.14,-3.14,0,0);
angle.add("positive",0,0,3.14,3.14);

LinguisticVariable power = factory.makeLinguisticVariable("power");

power.add("decreased",-2,-1,-1,0);
power.add("increased",0,1,1,2);

2. Create a fuzzy context

FuzzyState state = factory.makeFuzzyState();

3. Register all linguistic variables

state.register(angle);
state.register(power);

4. Load and parse rules

Reader ruleTextReader = /* create a java.io.Reader to the text rules */ ;
RuleBlock ruleBlock = fuzzyState.createRuleExecutionSet(ruleTextReader);

5. Peform fuzzy evaluations

ruleBlock.executeRules();

6. Obtain the result(s)

double result = power.defuzzify();