by Roland Stelzer, 2003

MyFuzzy.pm
is an open source fuzzy logic library developed in order to facilitate the
implementation of fuzzy control systems. First of all, an appropriate
programming language needed to be found for the development of fuzzy control
applications. Perl was the chosen programming language for the following
reasons:

*“Perl runs on Linux, Unix, Macintosh and Windows**Perl takes the best features from other languages, such as C, awk, sed, sh, and BASIC, among others.**Perl works with third-party databases like Oracle, Sybase, Postgres, and many others through the abstract database interface called DBI.**Perl can work with HTML, XML, and other mark-up languages.**Perl is open source”*

www.perl.org (2003)

Before
developing the library, the Internet was searched for existing solutions. The
only Fuzzy Logic Library written in Perl and freely was “AI::Fuzzy” from CPAN
(Comprehensive Perl Archive Network). Using this Perl module, it was possible
to design triangular fuzzy sets and carry out the fuzzification of values.
However, there are no inference mechanisms or defuzzification methods included
in this module. Therefore, a new library needed to be developed, with all the
functions necessary for a fuzzy control application.

The central
element used in the library is the fuzzy set. In MyFuzzy.pm the fuzzy sets are
discrete sets. This means, that they consist of a finite number of value pairs
(x,m(x)) with x Î {0,1,2,…,n}. The value n is called
the resolution of the fuzzy term.

All fuzzy
operations in MyFuzzy.pl round every crisp input – which has to be fuzzified –
to a natural number in {0,1,…,n}. The membership values are only defined for
this set of natural numbers.

A fuzzy set
A^{~} with a resolution n = 4 is shown in the figure 1.

Figure 1: Discrete Fuzzy Sets in MyFuzzy.pm

The crisp
input value 1.6 will be rounded to 2, because membership values are only
defined for natural numbers. The result of the fuzzification is m(round(1.6)) = m(2) = 1.

When a
resolution for a fuzzy term is to be found, it needs to be considered whether
maximum precision or maximum performance is required. If the resolution is low,
all fuzzy operations work very fast, but the level of precision for the
membership values is not very high. If precision is more important than
performance, a high resolution value should be taken.

To define
the fuzzy set A^{~ }from the example above using MyFuzzy.pm the
following code is needed.

$A->{0} = 0;

$A->{1} = 0.5;

$A->{2} = 1;

$A->{3} = 0.5;

$A->{4} = 0;

For larger
fuzzy terms, especially with a higher resolution, defining all the values would
be a lot of work. With the function interpolate this work can be reduced to a
minimum. Only the prominent values of the fuzzy set need to be defined. The
in-between values will be filled out automatically by *linear interpolation*. The result of the following code is exactly
the same as that of the last example.

The number
of value pairs is unlimited. For this reason you cannot only define standard
fuzzy sets like triangles or trapezoids.

$A->{0} =
0;

$A->{2} =
1;

$A->{4} =
0;

$A = **interpolate**($A);

The
examples above always employ a universe of discourse of [0,*n*]. In real
life the input values will not always be of this form. A good example of this
is a thermometer that measures the temperature outside in
°C. The temperature values for this will be in the interval [-50,50].
The MyFuzzy.pm library always works with x-values from 0 to *n*. Therefore
*transformation* is needed. The
following example shows the usage of the function transform_fuzzyterm.

The fuzzy
set B^{~} represents the linguistic term “hot” for outside temperature.

Assumption:
Resolution *n* = 100

$B->{20} = 0;

$B->{35} = 1;

$B->{50} = 1;

$B = **transform_fuzzyterm**(-50,50,$B);

$B = interpolate($B);

The
function transform_fuzzyterm transforms the x-values from the
interval [-50,50] into the interval [0,*n*]: in this case [0,100].

Figure 2: Interpolation in MyFuzzy.pm

When all
fuzzy sets are defined and transformed, the fuzzy rules have to be applied. A
fuzzy rule contains a condition and a conclusion. The condition is a single
fuzzy term or a combination of fuzzy terms, such as union (OR) or intersection
(AND).

The
following example demonstrates how a simple fuzzy rule is applied. The
procedure has to be done for every rule of the fuzzy system.

*Facts:* Room temperature = 25 °C

Outside
temperature = 30 °C

*Rule:* IF room_temperature IS hot

AND
outside_temperature IS hot

THEN aircondition IS full (degree of support = 1)

In this
example we use the fuzzy set of the previous example again. To keep the example
simple, the same fuzzy set is used for both the inside and outside temperature.
Assumed that it is still transformed into x-values of the interval [0,n] with a
resolution of n=100 again. The name of the fuzzy sets in the Perl code example
is: $room_temperature_hot and $outside_temperature_hot. It is also necessary to transform the input
values. The function transform_value is used to transform the
temperature values (inside: 25°C, outside: 30°C) to the internal representation
- a natural number in the interval [0,n].

$room_temperature = **transform_value**(-50,50,25);

$outside_temperature = **transform_value**(-50,50,30);

The new
“internal” room temperature value is now 75, outside temperature is 80. The
following command returns the corresponding membership values.

$mv_hot_room_temperature =

$room_temperature_hot->{$room_temperature};

$mv_hot_outside_temperature =

$outside_temperature_hot->{$outside_temperature};

The
variables now contain the fuzzified temperature:

m_{room_hot}(75) = 0.33 => $mv_hot_room_temperature = 0.33

m_{outside_hot}(80) = 0.66 => $mv_hot_outside_temperature = 0.66

Because the
antecedent of the rule combines two statements using the AND operator,
aggregation is necessary. This is done with the function fuzzy_aggregation. The specified
parameters are the logical operator and the membership values taken from the
fuzzification statements.

For the antecedent “room_temperature IS hot AND outside_temperature IS hot” the following Perl statement is needed to get the activation level of the rule:

$activation = **fuzzy_aggregation**( "AND",

$mv_hot_room_temperature,

$mv_hot_outside_temperature);

From this
we get the following degree of activation:

act_{Rule} = min(0.33,0.66) = 0.33 => $activation = 0.33

The
implication is done with the function fuzzy_implication. The first parameter of the
function is the used t-norm. In the example, the minimum operator is used. The
second parameter is the fuzzy set is given by the conclusion; in this case: “aircondition IS full”. The last parameter is the degree of rule
activation, multiplied by the degree of support.

$rule_result_fuzzyset =

**fuzzy_implication**( "min",

$aircond_full,

1*$activation));

Figure 3: Implication in MyFuzzy.pm

If there
are multiple rules, a result fuzzy set exists for each of them after their
implication. These fuzzy sets now need to be accumulated to a single result
fuzzy set for the whole fuzzy inference system.

The output
accumulation is done with the function fuzzy_accumulation, which combines two fuzzy sets using an
s-norm. We start with an output fuzzy set following the membership function m_{(x) }= 0. The initialisation is done with the
function init_fuzzyterm.

$aircond_result_fuzzyset = **init_fuzzyterm**(0);

Following
this, the accumulation can take place. The following statement has to be done
for every rule with a conclusion concerning the linguistic variable
“aircondition”. The parameters describe the used s-norm, the result fuzzy set,
and the fuzzy set to be accumulated (the result of the implication).

$aircond_result_fuzzyset =

**fuzzy_accumulation**( "max",

$aircond_result_fuzzyset,

$rule_result_fuzzyset);

After
applying all the rules of the fuzzy system in this way, the variable $aircond_result_fuzzyset contains the result fuzzy set.

The last
step is to defuzzify the output fuzzy set $aircond_result_fuzzyset. This can be done with the function defuzzify. The first parameter needed, specifies the defuzzification method to
use. The second parameter is the fuzzy set to be defuzzified.

$aircond_crisp =

**defuzzify**(“CoG”,
$aircond_result_fuzzyset);

The
variable $aircond_crisp now contains a natural number within the interval [0,*n*],
where *n* is the resolution of the fuzzy set. To get the real value
required to regulate the air condition, a retransformation is needed.

The
function retransform_value is the inversion of the function transform_value that was used at the beginning of the
inference process. As a result a given value from the internal representation
with the universe of discourse [0,*n*], is retransformed into the
user-defined interval for the fuzzy set [*min*,*max*].

**retransform_value**(0, 100,
$aircond_crisp);

In the
previous example, the retransformation will not have an effect because the
resolution *n* is 100, and the possible values for the air condition are
also between 0 and 100. Therefore, both intervals are [0,100].

Description: Rounds a floating-point number to
an integer

Parameters: number ... numeric value to round
mathematically

Return
value: Rounded value

Example: round (12.54);

returns 13

Description: Determines the minimum of given
values

Parameters: val_x ... numeric values

Return
value: smallest of the
parameter values

Example: max (12,54,100.3,-23);

returns –23

Description: Determines the maximum of given
values

Parameters: val_x ... numeric values

Return
value: largest of the parameter
values

Example: max (12,54,100.3,-23);

returns 100.3

Description: Aggregates the given values using
the specified logic operator.

Parameters: operator ... ‘AND‘, ‘OR‘

val_x ...
numeric values of the interval [0,1] (results of fuzzification)

Return
value: for operator ‘AND‘: Minimum
of the values

for operator
‘OR‘: Maximum of the values

Example: fuzzy_aggregation (‘AND‘,
0.54, 0.8);

returns 0.54

Description: Transforms a given value from a
given universe of discourse [min,max] into the internal representation of the
system with a universe of discourse defined by the resolution of the variables
of the fuzzy system [0,resolution].

Parameters: min ... lower limit of the source
universe of discourse

max ... upper
limit of the source universe of discourse

val ... numeric
values to transform into the internal representation [0,resolution]

Return
value: transformed value
(internal representation of the given value)

Example: A value of 30°C for the
outside temperature in the universe of discourse [-50,50] should be transformed
into the interval [0,100] (The resolution of the fuzzy sets is assumed to be
100). transform_value (-50,50,30);

returns 80

Description: This is the inversion of the
function transform_value. So a given value from the internal representation
with the universe of discourse [0,resolution] is retransformed into the user
defined interval for the fuzzy set [min,max].

Parameters: min ... lower limit of the source
universe of discourse

max ... upper
limit of the source universe of discourse

val ... numeric
values to retransform into [min,max]

Return
value: retransformed value

Example: We assume a resolution of 100.
The value 80 will be retransformed into the universe of discourse [-50,50] for
the outside temperature.

retransform_value
(-50,50,80);

returns 30(°C)

Description: Creates a new fuzzy term, with m(x) = val for every x in {0,1,..n}.

Parameters: val ... membership value out of
[0,1]

Return
value: Pointer to the
initialised fuzzy term.

Example: We assume a resolution of 4.

$newterm =
init_fuzzyterm(0.5);

The initialised
fuzzy set consists of {(0,0.5),(1,0.5),(2,0.5),(3,0.5),(4,0.5)}.

Description: Transforms a previously defined
fuzzyterm into its internal representation, depending on the resolution.

Parameters: min ... lower limit of the source
universe of discourse

max ... upper
limit of the source universe of discourse

fuzzytem ...
pointer to the previously defined fuzzy term

Return
value: Pointer to the
transformed fuzzy term.

Example: $B = **transform_fuzzyterm**(-50,50,$A);

Description: If only some membership values are
defined, this function interpolates between them.

Parameters: fuzzytem ... pointer to a fuzzy
set, with some defined members

Return
value: Fully defined fuzzy
term.

Example: $A = **interpolate**($A);

Description: Combines the given fuzzy sets
using the minimum operator.

Parameters: fuzzyterm_x ... pointers to fuzzy
terms

Return
value: Pointer to the result
fuzzy term.

Example: $C = fuzzy_and($A,$B);

Description: Combines the given fuzzy sets
using the maximum operator.

Parameters: fuzzyterm_x ... pointers to fuzzy
terms

Return
value: Pointer to the result
fuzzy term.

Example: $C = fuzzy_or($A,$B);

Description: Combines the given fuzzy sets
using the specified s-norm.

Parameters: s-norm … ‘max’ for maximum or ‘bdsum’
for bounded sum.

fuzzyterm_x ...
pointers to fuzzy terms

Return
value: Pointer to the result
fuzzy term.

Example: $C =
fuzzy_accumulation(‘bsum’,$A,$B);

Description: Combines the given value with
every membership value of the given fuzzy set using the specified t-norm.

Parameters: t-norm … ‘min’ for minimum or
‘prod’ for algebraic product.

fuzzytem ...
pointer to a fuzzy term

val … value
between 0 and 1

Return
value: Pointer to the result
fuzzy term.

Example: $C =
fuzzy_implication(‘min’,$A,0.7);

Description: Defuzzifies the given fuzzy set
using the specified defuzzification method.

Parameters: method … ‘CoG’ for centre of
gravity, ‘CoA’ for centre of area, ‘MoM’ for mean of maxima.

fuzzytem ...
pointers to fuzzy set to defuzzify

Return
value: crisp value (natural
number within the interval [0,n], where n is the resolution of the fuzzy set).

Example: $crisp = defuzzify(‘CoG’,$A);

Description: Reads the value out of the
specified device file.

Parameters: filename … name of the device file.

Return
value: value stored in the
device file.

Example: $value =
read_dev_file(’25.dev’);

Description: Writes the specified value into a
device file.

Parameters: filename … name of the device file.

$value … value
to store into the device file.

Return
value: none

Example: write_dev_file(’25.dev’,
17.5);

Description: Fetches the simulation input for
the current simulation cycle out of the database.

Parameters: varname … name of the linguistic
variable

vartype …
‘input’ or ‘output’ (usually it will be ‘input’).

Return
value: simulation input value.

Example: $value =
calc_next_input(’temperature’, ‘input’);

Description: Stores the input/output value of a
running fuzzy system into the database.

Parameters: varname … name of the linguistic
variable

vartype …
‘input’ or ‘output’.

Return
value: none

Example: store_value(’heating’,
‘output’);

Description: Deletes the output values from
previous runs in the database.

Parameters: none

Return
value: none

Example: delete_output(’heating’,
‘output’);

*FuzzyWeb* is a web application used to design fuzzy systems graphically. The source code of a designed fuzzy inference system can be generated automatically; it uses *MyFuzzy.pm*. Click the logo to try *FuzzyWeb*.