fuzzyset type

Each of the constructors returns an object which is of type fuzzyset .

While numeric values in the interval [0, 1] are not considered to be fuzzy sets, if they are used in a union or intersection, they will be interpreted as fuzzy sets.

>	Fz := L( 3, 4 );

>	type( Fz, fuzzyset );

FuzzySet Constructor

The fuzzy set constructor FuzzySet  is similar to the piecewise  function.
An odd number of arguments must be given.

>	FuzzySet( x < 3, 0, x = 4, 1, x = 5, 1/2, x = 6, 1, x = 7, 0, 0 );

>

plot(%);

>	FuzzySet( x < 3, 0, x < 4, 1/2, x = 6, 1, 1 );

>	plot( %, 2..7, axes = none );

Other Constructors and Models

The constructors Gamma ( ), L ( ), Lambda ( ), and PI ( ) are named to suggest the shape of the resulting membership function.
For example, Gamma produces fuzzy sets whose functions monotonically increasing from 0 to 1, while L produces fuzzy sets whose membership function decreases from 1 to 0.

In words, these subsets of R would be described as:

  1.  Real numbers approximately less than a given value ( ),
  2.  Real numbers approximately greater than a given value ( ),
  3.  Real numbers approximately equal to a given value ( ).
  4.  Real numbers on or close to an interval ( ).

The transition from real numbers having full membership (1) in the associated set and having no membership (0) depends on the type of membership function used.
The membership functions provided use standard algebraic expressions to describe the membership of a real number within the fuzzy set, and the type of expression (or model) used may be specified.
For example, the linear model uses a piecewise linear function to represent the transition from 0 to 1 (or 1 to 0.)

The  constructor is used to represent real numbers approximately greater than or equal to a given value.

The linear model takes two arguments a, b and creates a linear function which interpolates the points (a, 0), (b, 1).
        

The quadratic model (Zadeh's S function) interpolates the points with two quadratics which are smooth at each end point.
        

The cubic model interpolates the two points which a cubic  the derivative of which is 0 at each end point.
        

The rational model takes one argument a and creates a rational function  which is zero at a and approaches  as .
It takes a parameter  which is 1 by default.
        

The exponential model does the same, but uses an exponential function.
It takes a parameter  which is 1 by default.
       
The arctangent and hyperbolic tangent models take one argument a creates a fuzzy set S such that .
They both take parameters .
        
        

Parameters are passed by using an index.  See the examples below.

>	Gamma( 3, 4 );

>	plot( [   Gamma( 1, 4 ), Gamma( 1, 4, model=quadratic ), Gamma( 1, 4, model=cubic ) ], 0..5, legend=["Linear", "Quadratic", "Cubic"], color=[red, blue, black] );

>	plot( [   Gamma( 1, model=rational ), Gamma( 1, model=exp ),   Gamma( 1, model=rational[2] ), Gamma( 1, model=exp[2] ) ], -2..2, color = [red, blue, black, magenta], legend=[   "Rational", "Exponential",   "Rational with parameter 2", "Exponential with parameter 2" ] );

>	plot( [   Gamma( 1, model=arctan ), Gamma( 1, model=tanh ),   Gamma( 1, model=arctan[2] ), Gamma( 1, model=tanh[2] ) ], -3..5, color = [red, blue, black, magenta], legend=[   "Arctangent", "Hyperbolic Tangent",   "Arctangent with parameter 2", "Hyperbolic Tangent with parameter 2" ] );

L

The  constructor does the same as the Gamma constructor, except it goes down from (a, 1) to (b, 0).

>	L( 3, 4 );

>	plot( [   L( 1, 4 ), L( 1, 4, model=quadratic ), L( 1, 4, model=cubic ) ], 0..5, color = [red, blue, black], legend=["Linear", "Quadratic", "Cubic"] );

>	plot( [   L( 1, model=rational ), L( 1, model=exp ),   L( 1, model=rational[2] ), L( 1, model=exp[2] ) ], 0..5, color = [red, blue, black, magenta], legend=[   "Rational", "Exponential",   "Rational with parameter 2", "Exponential with parameter 2" ] );

>	plot( [   L( 1, model=arctan ), L( 1, model=tanh ),   L( 1, model=arctan[2] ), L( 1, model=tanh[2] ) ], -3..5, color = [red, blue, black, magenta], legend=[   "Arctangent", "Hyperbolic Tangent",   "Arctangent with parameter 2", "Hyperbolic Tangent with parameter 2" ] );

The  function takes models similar to that of the  and  functions except that it is used to model an approximation to a point, so

the definitions must be appropriately adjusted.

The arctangent and hyperbolic tangent models do not apply to the  function.

>	Lambda( 3, 4, 5 );

>	plot( [   Lambda( 1, 3, 5 ), Lambda( 1, 3, 5, model=quadratic ), Lambda( 1, 3, 5, model=cubic ) ], 0..6, color = [red, blue, black], legend=["Linear", "Quadratic", "Cubic"] );

>	plot( [   Lambda( 3, model=rational ), Lambda( 3, model=exp ),   Lambda( 3, model=rational[2] ), Lambda( 3, model=exp[2] ) ], 0..6, color = [red, blue, black, magenta], legend=[   "Rational", "Exponential",   "Rational with parameter 2", "Exponential with parameter 2" ] );

The PI function is similar to the Lambda function except it contains an interval on which fuzzy membership is 1.

>	PI( 3, 4, 5, 6 );

>	plot( [   PI( 1, 3, 5, 7 ), PI( 1, 3, 5, 7, model=quadratic ), PI( 1, 3, 5, 7, model=cubic ) ], 0..8, color = [red, blue, black], legend=["Linear", "Quadratic", "Cubic"] );

>	plot( [   PI( 3, 4, model=rational ),    PI( 3, 4, model=exp ),   PI( 3, 4, model=rational[2] ), PI( 3, 4, model=exp[2] ) ], 0..7, legend=[   "Rational", "Exponential",   "Rational with parameter 2", "Exponential with parameter 2" ] );

Partition

For a linear, quadratic, or cubic model, the  function takes a sequence of points and generates a set of  functions of each triplet of points.
For the other models, it creates the associated  fuzzy set for each point.
The arguments must be ordered apriori.

>	Partition( 3, 4, 6, 8, 9 );

>	plot( [Partition( 3, 5, 7, 9, 11 )], 1..13 );

>	plot( [Partition( 3, 5, 7, 9, 11, model = quadratic )], 1..13 );

>	plot( [Partition( 3, 5, 7, 9, 11, model = cubic )], 1..13 );

>	plot( [Partition( 3, 5, 7, 9, 11, model = rational[2] )], 1..13 );

Union (union)

The union of two fuzzy sets S and T has the membership function .
By default, this is equal to:   .  This is equal to the join  of the two membership functions.
The default s-norm used to calculate the union may be changed using the Tools[UseTNorm]  function.

>	plot( [S, T, S union T], 1..9, thickness=[1, 1, 3], color=[red, blue, black] );

>	S union T;

Intersection (intersect)

The intersection of two fuzzy sets S and T has the membership function .
By default, this is equal to:   .  This is equal to the meet  of the two membership functions.
The default t-norm used to calculate the union may be changed using the Tools[UseTNorm]  function.

>	plot( [S, T, S intersect T], 1..9, thickness=[1, 1, 3], color=[red, blue, black] );

Implication (implies)

The amount to which one fuzzy set implies another has numerous member functions.  According to classical logic, the definition may have the membership function .
By default, this is equal to:   .
The default implication used to calculate implication may be changed using the Tools[UseImplication]  function.

>	plot( [S, T, S implies T], 1..9, thickness=[1, 1, 3], color=[red, blue, black] );

>	plot( [S, 0.3, S implies 0.3, 0.3 implies S], 1..9, thickness=[1, 1, 3, 3], color=[red, blue, black, cyan] );

Membership (in)

The in  operator returns the degree of membership of the left hand side in the given fuzzy set.  The following are equivalent for numeric :   .

>

3.2 in S;

>

3.2 in T;

>

3.2 in U;

>	plot( [S, T, U], 3..4, color = [red, blue, black] );

Set Minus (minus)

The minus operator is defined as .
Alternatively, one may define it as , but the Arithmetic  subpackage may be used for this purpose.  Otherwise, there would be no access to fuzzy implications through the FuzzySets[RealDomains]  package.

>	(S minus T) subset S;

>	FuzzySets:-Logic:-`not`( 0.2 );

>	plot( [S, T, S minus T], 1..9, color=[red, blue, cyan], thickness = [1, 1, 3] );

Subset (subset)

A fuzzy set S is a subset of a fuzzy set T if  for all real .

>	T subset S;

>	S subset U;

>	U subset S;

Arithmetic Subpackage

The Arithmetic  subpackage allows you to take sums, differences, and products of fuzzy sets.
As such operations are less common on fuzzy sets, they are included in a subpackage so as to not interfer with the standard Maple interface.
As these are not common, they are placed in a separate subpackage rather than overriding +, -, and * when you load the FuzzySet[RealDomains]  package.

>	use FuzzySets:-RealDomain:-Arithmetic in   plot( [S, T, S + T, S - T, S * T], 0..9, color = [red, blue, black, cyan, magenta], thickness = [1, 1, 3, 3, 3], legend = ["S", "T", "S + T", "S - T", "S * T"] ); end use;

Complement

The complement of a fuzzy set has the membership function .

By default, it is equal to .
The default complement used may be changed using the Tools[UseComplement]  function.

>	plot( [T, Complement( T )], 1..9, color=[red, black] );

Converting Fuzzy Sets to Piecewise Functions ( )

The  operator can be thought of as the equivalent of .
The notation  is used throughout the literature of fuzzy sets.

>

mu[S](x);

Defuzzify

>	Defuzzify( T );

>	Defuzzify( Lambda( 0, 3, 9 ) );

>	Defuzzify( S );   # Error

Error, (in FuzzySets:-RealDomain:-Defuzzify) cannot defuzzify an unbounded fuzzy set on an infinite interval

Cut

The fuzzy weak -level cut  of a fuzzy set  is defined as the fuzzy set whose membership function is:

       

This is the default result given by the function Cut .

The crisp weak -level cut  for a fuzzy set  is defined as the fuzzy set whose membership function is:
       

This result may be achieved through the use of the option crisp = true .

The strong alpha-level cut  of a fuzzy set A is defined as the fuzzy set whose membership function is:

      

This result may be achieved through the use of the option strong = true .

Both options may be used together to get a crisp set which is  whenever .

>	Cut( S, 0.3 );                 # fuzzy and weak

>	Cut( S, 0.3, crisp );          # crisp and weak

>	Cut( S, 0.3, strong );         # fuzzy and strong

>	Cut( S, 0.3, crisp, strong );  #crisp and strong

>	plot( [S, Cut( S, 0.3 ), Cut( S, 0.3, crisp )], 2..5, color=[red, blue, black], thickness = [1, 3, 4] );

Core

The core of a fuzzy set S is the set of all points for which .
It may be thought of as the crisp weak 1-level cut of a fuzzy set.

>	Core( S );

Support

The support of a fuzzy set S is the set of all points for which .
It may be thought of as the crisp strong 0-level cut of a fuzzy set.

>	Support( S );

Height

The height of a fuzzy set is the supremum of the membership function .

>	Height( S );

>	Height( S intersect T );

Normalize

A fuzzy set is called normal if it is either the empty set (0) or there exists an element  such that , that is, .
The normalize function divides a fuzzy set by its height to produce a normal fuzzy set.

>	Normalize( S );

>	Normalize( S intersect T );

>	plot(   [S intersect T, Normalize( S intersect T )],   1..5, color=[red, blue], legend = ["U = S intersect T", "Normalize( U )"] );

Concentate

>	C1 := Lambda( 3, 4, 5 );

>	C2 := Concentrate( C1 );

>	C3 := Concentrate( C1, 3 );

>	plot( [C1, C2, C3], 2..6, color = [red, blue, black] );

Dilate

>	D1 := Lambda( 3, 4, 5 );

>	D2 := Dilate( D1 );

>	D3 := Dilate( D1, 3 );

>	plot( [D1, D2, D3], 2..6, color = [red, blue, black] );

IntensifyContrast

>	IC1 := Lambda( 3, 4, 5, model=quadratic );

>	IC2 := IntensifyContrast( IC1 );

>	plot([IC1, IC2], 2..6 );

Constructors

Plotting

>	plot( S );

>	plot( R );

Operators on Fuzzy Sets with a Finite Nonnumeric Domain

The properites of the operators are identical to the descriptions given in the section Operators on Fuzzy Sets with a Real Domain .

>	S := FuzzySet( x = 0.3 );

>	T := FuzzySet( x = 0.2, y = 1 );

Functions on Fuzzy Sets with a Finite Nonnumeric Domain

Unless stated otherwise, the properites of these functions are identical to the descriptions given in the section Operators on Fuzzy Sets with a Real Domain .

>	S := FuzzySet( x = 0.3 );

>	T := FuzzySet( x = 0.2, y = 1 );

Constructors

Plotting

>	plot( T );

>	plot( R );

Operators on Fuzzy Sets with a Finite Numeric Domain

The properites of the operators are identical to the descriptions given in the section Operators on Fuzzy Sets with a Real Domain .

>	S := Lambda( 3, 5, 7 ):

>	T := Lambda( 2, 6, 10 ):

>	plot( [S, T] );

Functions on Fuzzy Sets with a Finite Numeric Domain

Unless stated otherwise, the properites of these functions are identical to the descriptions given in the section Operators on Fuzzy Sets with a Real Domain .

>	S := Lambda( 3, 5, 7 ):

>	T := Lambda( 2, 6, 10 ):

An Introduction To T-Norms and S-Norms

Up until now, we've used  and  to calculate operations on two fuzzy numbers.

In general, we may use triangular-norms  ( t-norms ) and s-norms  (or t-conorms ) to define or  and and , respectively.

An s-norm :[0,1] x  ( or ) must satisfy:
  1.  Symmetry:  s(x, y) = s(y, x)
  2.  Associativity:  s(x, s(y, z)) = s(s(x, y), z)
  3.  Boundary conditions:   s(x, 0) = x  and s(x, 1) = 1
  4.  Monotonicity:  if  and  then

A t-norm ( and ) must satisfy:
  1.  Symmetry:  
  2.  Associativity:  
  3.  Boundary conditions:    and
  4.  Monotonicity:  if  and  then  

The default s-  and t-norms  are  and , respectively.
The drastic sum s-  and t-norms  are defined as  and .


Theorem
For any s-norm s  and t-norm t , the following inequalities holds:
      
    

The Dombi s-  and t-norms  with parameter (0, ) are  and .

Theorem
The Dombi s- and t-norms have the properties that:
     ,
     .
     , and
     .


The available norms are given here:

default
    
Hamacher
    
algebraic
    

Einstein
    
bounded
    

To use any of these alternate norms, use the UseNorm function with the argument being the norm you wish to use.

Warning:  some norms are more complicated and others and may not result in objects which Maple can work with.

>	with( FuzzySets[RealDomain] ):

Warning, the name implies has been rebound

Warning, these protected names have been redefined and unprotected: intersect, minus, plot, subset, union

>	S := Gamma( 3, 5 );

>	T := L( 3, 5 );

>	plot( [S, T, S minus T, S union T, S intersect T], 0..10 );

>	FuzzySets:-Tools:-UseSNorm( algebraic ); FuzzySets:-Tools:-UseTNorm( algebraic );

>	plot( [S, T, S minus T, S union T, S intersect T], 0..10, numpoints=1000 );

>	FuzzySets:-Tools:-UseSNorm( default ); FuzzySets:-Tools:-UseTNorm( default );

Use Norms

The routine  can be used to change the default norm being used.  Available norms are listed by the  routine.

For simple norms (t- and s-norms) not taking any parameters, the calling sequence is:

>	FuzzySets:-Tools:-UseSNorm( bounded ); FuzzySets:-Tools:-UseTNorm( bounded );

The return value is the previously used norm.

>	FuzzySets:-Tools:-UseSNorm( default ); FuzzySets:-Tools:-UseTNorm( default );

Norms may be parameterized, in which case, the parameters are passed by indexing the name of the norm with the parameters.
For an example of this, see the  section.

Get S- and T-Norms

The routines GetSNorms  and GetTNorms  return an expression sequence of all available s- and t-norms, respectively.

>	GetSNorms();

>	GetTNorms();

Plotting S- and T-Norms

>	with( FuzzySets:-Tools );

>	PlotSNorm( algebraic, axes = box );

>	PlotTNorm( algebraic, axes = box );

Add Norm

The procedure AddNorm allows you to add new t- and s-norms (t-conorms).

>	AddSNorm( mynorm, (x, y) -> max( 0, -1 + x + y ) ); AddTNorm( mynorm, (x, y) -> min( x + y, 1 ) );

>	UseSNorm( mynorm ); UseTNorm( mynorm );

>	with( FuzzySets[Logic] );

Warning, the name implies has been rebound

>

1 and 0;

>

0 or 0.5;

>	PlotTNorm( mynorm );

>	PlotSNorm( mynorm );

Use Implication

>

Add Implication

>

Get Implications

This procedure takes no arguments and returns an expression sequence of all available implications.

>	GetImplications();

Many of these negations are more general than their

Plot Implication

>	PlotImplication( default );

Use Complement

The UseComplement routine takes one argument that defines a negation to be used.
The return value is the negation that was previously being used.

>	UseComplement( cos );

>

not 0.3;

>

not %;

Note that it is not always true that , as is demonstrated above.

Some negations may use parameters, which are specified by giving the name of the negation an index:

>	UseComplement( Yager[1.3] );

>

not 0.3;

>

not %;

Get Complements

The GetComplements  routine takes no arguments and returns an expression sequence of all available negations.

>	GetComplements();

Plotting Complements

The PlotComplement  routine plots one or more negations from [0, 1] to [0, 1].

>	PlotComplement( [default, cos, Yager[1.2], Yager[1.4]], color = [red, blue, grey, black], legend = ["Default", "Cosine", "Yager 1.2", "Yager 1.4"] );

Add Complement

You can add new negations by using the AddComplement  routine.  It takes two arguments:  a symbol denoting the negation and an operator.
By definition, a negation should be a function that decreases monotonically from 1 to 0 on the interval .
If the negation uses parameters, the parameters must be the 2nd, 3rd, and subsequent arguments of the parameter.
This example adds a negation called step  that takes one parameter a  that should be in the interval .

>	AddComplement( mystep, (x, a) -> piecewise( x < a, 1, 0 ), properties = [RealRange( Open(0), Open(1) )] );

>	UseComplement( mystep[0.3] );

>

not 0.2;

>

not 0.3;

>

not 0.9;

>	UseComplement( mystep[1.3] ); # Error

Error, (in FuzzySets:-Tools:-UseComplement) the parameter 1.3 should have the property RealRange(Open(0),Open(1))

Adding Gamma Models

The  constructor will recognize the first argument as a model for a fuzzy set where membership approaches  as the element approaches  and  as the element approaches .

>	AddGammaModel( cos, (r, a, b) -> ( r < a, 0, r < b, 1/2 + cos( -Pi*(r-b)/(a-b) )/2, 1 ) );

>	Gamma( 1, 2, model = cos );

>	plot( %, 0..3 );

Adding L Models

The  constructor will recognize the first argument as a model for a fuzzy set where membership approaches  as the element approaches  and  as the element approaches .

>	AddLModel( cos, (r, a, b) -> ( r < a, 1, r < b, 1/2 - cos( -Pi*(r-b)/(a-b) )/2, 0 ) );

>	L( 1, 2, model = cos );

>	plot( %, 0..3 );

Adding Lambda Models

The  constructor will recognize the first argument as a model for a fuzzy set where membership equals  for a specific element and approaches and  as the elements approach  or .

>	AddLambdaModel( cos, (r, a, b, c) -> (     r < a, 0, r < b, 1/2 + cos( -Pi*(r-b)/(a-b) )/2, r < c, 1/2 - cos( -Pi*(r-c)/(b-c) )/2, 0 ) );

>	Lambda( 1, 2, 3, model = cos );

>	plot( %, 0..4 );

Adding PI Models

The  constructor will recognize the first argument as a model for a fuzzy set where membership equals  for a specific element and approaches and  as the elements approach  or .

>	AddPIModel( cos, (r, a, b, c, d) -> (     r < a, 0, r < b, 1/2 + cos( -Pi*(r-b)/(a-b) )/2, r < c, 1, r < d, 1/2 - cos( -Pi*(r-d)/(c-d) )/2, 0 ) );

>	PI( 1, 2, 3, 4, model = cos );

>	plot( %, 0..5 );