JT2FIS: Java Type-2 Fuzzy Inference System

An Object-oriented Class Library for Building Java Intelligent Applications

Manuel Casta

on-Puga, Juan-Ram

on Castro and Miguel Flores-Parra

Facultad de Ciencias Qu

ımicas e Ingenier

ıa, Universidad Aut

onoma de Baja California, Tijuana, M

exico

Keywords:

Computational Intelligence, Type-2 Fuzzy Inference System, Java Fuzzy Systems Class Library.

Abstract:

This paper introduces a Java



class library for fuzzy systems that can be used to build an Interval Type-2

Fuzzy Inference System. Architecture of the system is presented and object oriented design and modules are

described. We use the Water Temperature and Flow Controller as a classic example to benchmark the inputs

and outputs and to show how to use it on engineering. We compare the developed library with an existing

Matlab



library in order to discuss the Java



object oriented approach and its applications.

1 INTRODUCTION

Fuzzy inference systems (FIS) have been broadly

used for a wide engineering applications. Especially,

FIS have been successfully applied in control systems

and decision-making systems and the main advantage

is the way to deal with imprecise information about

some system variable and let us to work with.

The most of the FIS used until now are FIS based

on a Type-1 model (Zadeh, 1965), but lately, a Type-

2 model have been developed and others applications

are been extended with it (Zadeh, 1973). The state

of the art led us to Type-2 General Fuzzy Inference

Model (Lucas, 2007) that have been developed as a

next step on the way to have Fuzzy Inference Sys-

tems with more capability to model real-world things

(Castillo and Melin, 2008)(Castillo et al., 2010).

The purpose of this paper is to introduce a Java

class library for fuzzy systems that can be used to

build an Interval Type-2 Fuzzy Inference System.

1.1 Type-2 Fuzzy Inference System

A fuzzy inference system (FIS) is based on logical

rules that can work with numeric values or fuzzy in-

put, rules are evaluated and the individual results to-

gether to form what is the output fuzzy, then, a nu-

merical value must be passed through a process of de-

fuzziﬁcation if its required. Figure 1 shows a block

diagram of the classic structure of a FIS.

The concept of a type-2 fuzzy set was introduced

by Zadeh (Zadeh, 1975) as an extension of the con-

cept of fuzzy sets usually type 1. A type-2 fuzzy set is

Figure 1: Type-2 Fuzzy Inference System block diagram.

characterized by a membership function whose mem-

bership value for each element of the universe is a

membership function in the range [0, 1], unlike the

type-1 fuzzy sets where the value of membership is a

numeric value in the range [0, 1]. The creation of a

fuzzy set depends on two aspects: the identiﬁcation

of a universe of appropriate values and specifying a

membership function properly. The choice of mem-

bership function is a subjective process, meaning that

different people can reach different conclusions on the

same concept. This subjectivity is derived from indi-

vidual differences in the perception and expression of

abstract concepts and very little to do with random-

ness. Therefore, subjectivity and randomness of a

fuzzy set is the main difference between the study of

fuzzy sets and probability theory (Jang et al., 1997).

In type-1 fuzzy sets, once the membership func-

tion deﬁned for a concept, this is based on the sub-

jective opinion of one or more individuals and shows

no more than one value for each element of the uni-

524

Castañón-Puga M., Castro J. and Flores-Parra M..

JT2FIS: Java Type-2 Fuzzy Inference System - An Object-oriented Class Library for Building Java Intelligent Applications.

DOI: 10.5220/0004569805240529

In Proceedings of the 15th International Conference on Enterprise Information Systems (ICEIS-2013), pages 524-529

ISBN: 978-989-8565-59-4

 2013 SCITEPRESS (Science and Technology Publications, Lda.)

Figure 2: Type-1 fuzzy set and type-2 fuzzy set with uncer-

tainty.

verse. In doing so, it lose some of the ambiguity that

some concepts are discussed, especially where people

may have a slightly different opinion and all are con-

sidered valid. The type-2 fuzzy sets allow handling

linguistic and numerical uncertainties. Figure 2 de-

picts two graphics of fuzzy sets, a) with type-1 fuzzy

logic, and b) with type-2 fuzzy logic.

In a) the values set shown is A = {(x, µ

(x))|x ∈

X} where A ⊆ X, X A ⊆ X, X is the universe of valid

values and µ

(x) is the membership function (MF)

that contains a map of each value of X with its mem-

bership value corresponding to a value between 0 and

1. For b) the values set is

A = {((x, u), µ

(x, u))},

where MF µ

(x, u) has a membership value for each

element of the universe as a function of membership

in the range [0, 1], so the footprint can be seen around

the curve of a).

1.2 Type-2 Fuzzy Inference System

Applications

Concepts such as large/small or fast/slow can be rep-

resented as fuzzy sets, thus allowing that there may

be slight variations in the deﬁnition for common con-

cepts, an example of this can be shown in (Wagner

and Hagras, 2010). When dealing with a ﬁxed set of

actions but with different criteria to decide what ac-

tion to take, you can use fuzzy logic as a viable op-

tion to deﬁne the behavior proﬁles. There are many

applications where fuzzy logic has been used, for ex-

ample, a simulation of the bird age-structured popu-

lation growth based on an interval type-2 fuzzy cel-

lular structure (Leal-Ram

ırez et al., 2011), optimiza-

tion of interval type-2 fuzzy logic controllers using

evolutionary algorithms (Castillo et al., 2011), an im-

proved method for edge detection based on interval

type-2 fuzzy logic (Melin et al., 2010), a hybrid learn-

ing algorithm for a class of interval type-2 fuzzy neu-

ral networks (Castro et al., 2009), a systematic design

of a stable type-2 fuzzy logic controller (Castillo and

Melin, 2008), and an efﬁcient computational method

to implement type-2 fuzzy logic in control applica-

tions (Sep

ulveda et al., 2007).

1.3 Object Oriented Fuzzy Inference

Systems

There are available code libraries and tool-kits to

build Fuzzy Inference Systems. Some of this pack-

ages are object oriented class libraries that are devel-

oped mainly for build Type-1 Fuzzy Logic with an ob-

ject oriented programming language (Garc

ıa-Valdez

et al., 2007). jFuzzyLogic (Cingolani and Alcala-

Fdez, 2012) is an example of a class library written

in Java The advantage of an Fuzzy Inference System

in Java is that we could build intelligent systems with

Type-2 Fuzzy Logic capabilities using a object ori-

ented programming language. Java is a robust general

use object oriented programming language used in a

wide range of applications.

2 JT2FIS ARCHITECTURE

JT2FIS is a class library developed for Java. The

main purpose is to deploy a library for build type-2

fuzzy inference systems with a object oriented pro-

gramming language.

A Java library turns important due is very conve-

nient for reuse and legibility of coding, and system

portability.

2.1 JT2FIS Design

JT2FIS is integrated by a package structure that con-

tains all classes collection. The package containment

are organized and depicted in Table 1.

The library takes advantage of heritage capability

of object-oriented paradigm to integrate new member-

ship features. We can see this approach in ﬁg. 3 where

MemeberFunction are an abstract class that let us to

extends as member functions as we require.

In JT2FIS version 1.0 we have seven different

type-2 member functions and a core of type-1 mem-

ber functions available (Gauss, Triangular, Trape-

zoidal). Table 2 list type-2 member function available

in the library.

The Figure 4 depicts JT2FIS expressed in Uni-

ﬁed Modeling Language (UML). The class structure

JT2FIS are shown.

Fis classes are composed by a set of inputs (Input

class), outputs (Output class) and rules (Rule class).

Each input and output contain a set off member func-

tions (MemberFunction class) and each one could be

a speciﬁc type of member function.

The Fis class provides the main features of an In-

terval Type-2 Fuzzy Inference System. Fis class is

an abstract class that establishes the core functionality

JT2FIS:JavaType-2FuzzyInferenceSystem-AnObject-orientedClassLibraryforBuildingJavaIntelligentApplications

525

Table 1: JT2FIS library packages content.

Package Content

Fis Fis Class

Mamdani Class

Defuzziﬁer Package

Fuzziﬁer Package

MF Package

Defuzziﬁer Defuzzy Class

TypeReducer Package

TypeReducer TypeReducer Class

Fuzziﬁer Fuzzify Class

Mf MemberFunction Class

type1 Package

type2 Package

Type1 BellMemberFunction Class

GaussMemberFunction Class

TrapezoidalMemberFunction Class

TriangulerMemberFunction Class

Type2 GaussCutMemberFunction Class

GaussUncertaintyMeanMemberFunction Class

GaussUncertaintyStandardDesviationMemberFunction Class

TrapaUncertaintyMemberFunction Class

TrapezoidalUncertaintyMemberFunction Class

TriangulerUncertaintyMemberFunction Class

TriUncertaintyMemberFunction Class

Structure Input Class

Output Class

Rule Class

Figure 3: Member Functions Types.

and extends to Mamdani and Sugeno concrete classes

that implements different approaches.

We can expand member function types extending

the core class MemberFunction class. Figure 5 show

actual member function available.

Table 2: JIT2FIS Type-2 Member Functions.

PackageType-2 Member Functions Description

GaussCutMemberFunction Params =[sigma mean alfa]

GaussUncertaintyMeanMemberFunction Params=[sigma mean1 mean2]

GaussUncertaintyStandardDesviationMemberFunction Params=[sigma1 sigma2 mean]

TrapaUncertaintyMemberFunction Params=[a1 b1 c1 d1 a2 b2 c2 d2 alfa]

TrapezoidalUncertaintyMemberFunction Params=[a d sa sd sn alfa]

TriangulerUncertaintyMemberFunction Params=[a c sa sc]

TriUncertaintyMemberFunction Params=[a1 b1 c1 a2 b2 c2]

Figure 4: JT2FIS core class structure.

2.2 Building a Interval Type-2 Fuzzy

Inference System

In order to create a FIS with JT2FIS in the next exam-

ple, we are considering the following procedure:

1. Create a new instance of FIS class.

2. Create and conﬁgure new inputs instances of In-

put class to add to the FIS.

3. Create and conﬁgure new outputs instances of

Output class to add to the FIS.

4. Create and conﬁgure new rules instances of Rule

class to add to the FIS.

5. Evaluate inference with build FIS.

2.2.1 Creating a New FIS Instance

To build an Interval Type-2 Fuzzy Inference System,

ﬁrst we have to create an instance of Mamdani class.

Listing 1 shows how to do that.

Listing 1: Creating a new instance of FIS.

Mamd an i f is = new Ma md an i (" FIS ") ;

ICEIS2013-15thInternationalConferenceonEnterpriseInformationSystems

526

Figure 5: Fuzzy Inference Systems Types.

2.2.2 Adding inputs to FIS

Second, we can add inputs creating instances of Input

class. For each input instance, we can add a member

function that will represents a linguistic input variable

in the system. Member functions could be from dif-

ferent type, depending of the application.

Listing 2 shows how to add member function to

an input, and how to add an input to ﬁs.

Listing 2: Adding a new input of FIS.

/ / C r e a t i n g a new I n p u t i n s t a n c e

I n p u t i n p u t =new I n p u t ( ” i n p u t ” ) ;

/ / C o n f i g u r i n g i n p u t r a n g e s

i n p u t . se t Lower R a n g e ( −2 0 . 0 ) ;

i n p u t . s e t S u p e r i o r R a n g e ( 2 0 . 0 ) ;

/ / C r e a t i n g a i n p u t member f u n c t i o n

G a u ssU n cer t ain t y Me a n Me m b er F u nc t i on

inputMF = new

G a u ssU n cer t ain t y Me a n Me m b er F u nc t i on (

” InputMF ” ) ;

/ / C o n f i g u r i n g i n p u t member f u n c t i o n

inputMF . s e t S i g m a ( −6 . 0 ) ;

inputMF . se t M e a n1 ( −1 2. 0) ;

inputMF . se t M e a n2 ( −1 8. 0) ;

/ / A d d i ng member f u n c t i o n t o i n p u t

i n p u t . ge t Me m be r Fu n ct i on s ( ) . add ( inputMF

) ;

/ / A d d i ng i n p u t t o f i s

f i s . g e t I n p u t s ( ) . add ( i n p u t ) ;

2.2.3 Adding outputs to FIS

Third, we can add outputs creating instances of Out-

put class. In the same way the inputs, for each out-

put instance, we can add a member function that will

represents a linguistic output variable in the system.

Member functions could be from different type, de-

pending of the application.

Listing 3 shows how to add member function to

an output, and how to add an output to ﬁs.

Listing 3: Adding a new output of FIS.

/ / C r e a t i n g a new O u t pu t i n s t a n c e

O u t p u t o u t p u t =new O u t p u t ( ” o u t p u t ” ) ;

/ / O ut p ut ra n g e s

o u t p u t . se t Lower R a n g e ( −1 . 0 ) ;

o u t p u t . s e t S u p e r i o r R a n g e ( 1 . 0 ) ;

/ / C r e a t i n g a o u t p u t member f u n c t i o n

G a u ssU n cer t ain t y Me a n Me m b er F u nc t i on

output MF=new

G a u ssU n cer t ain t y Me a n Me m b er F u nc t i on (

” OutputMF ” ) ;

/ / C o n f i g u r i n g o u t p u t member f u n c t i o n

output MF . s e t S i g m a ( −1. 0 5 ) ;

output MF . s e t M ean1 ( −0 . 65) ;

output MF . s e t M ean2 ( −0 . 35) ;

/ / A d d i ng member f u n c t i o n t o o u t p u t

o u t p u t . ge t Me m be r Fu n ct i on s ( ) . add (

output MF ) ;

/ / A d d i ng o u t p u t t o f i s

f i s . g e t O u t p u t s ( ) . a dd ( o u t p u t ) ;

2.2.4 Adding rules to FIS

Finally, we can add rules to ﬁs. Each rule is composed

by a set of antecedents and a set of consequents. An-

tecedents and consequents are member functions that

are part of inputs and outputs.

Listing 4 shows how to add antecedents and con-

sequents to rule, and how to add a rule to ﬁs.

Listing 4: Adding a new rule of FIS.

//Creating a new Rule instance

Rul e ru le =new R u le () ;

//Adding antecedent to rule

Me m be r F u n c t i o n ant e ce de n t = fis .

ge tI n pu ts () . get ( 0) .

ge t M em b e r F u nc t i o n s () . get ( 0 ) ;

rul e . g e tA n te c ed e nt s () . add (

an t ec ed e nt ) ;

//Adding consecuent to rule

Me m be r F u n c t i o n con c ec ue n t = fis .

ge t Ou tp u ts () . get ( 0) .

ge t M em b e r F u nc t i o n s () . get ( 0 ) ;

ru l e1 . ge t C o n s e q u en t s () . add (

co n ce cu e nt ) ;

//Adding rule to fis

fis . g e t R ul es () . add ( r ule ) ;

2.2.5 Evaluating inference with FIS

Once the system is built, we can use it to evaluate

input and output values. JT2FIS have 5 different

ways to evaluate ﬁs. Each way is a method of re-

duction (Centroid, Center-of-Sums, Height, Modiﬁed

Height, Center of Sets). Each method has parameters

that must be conﬁgured depending of representation

needs.

Listing 5 shows how to conﬁgure and evaluate the

ﬁs.

Listing 5: Evaluating inference with FIS.

/ / C o n f i g u r i n g e v a l u a t i o n p a r a m e t e r s

JT2FIS:JavaType-2FuzzyInferenceSystem-AnObject-orientedClassLibraryforBuildingJavaIntelligentApplications

527

i n t p o i n t s = 1 01 ;

i n t andMethod = 0 ;

i n t orMethod = 0;

i n t impMethod = 0 ;

i n t aggMethod = 0 ;

/ / C r e a t i n g a new i n p u t S t a c k o f

i n p u t L i s t

A r r a y L i s t <A r r a y L i s t <Double>>

i n p u t S t a c k = new A r r a y L i s t <

A r r a y L i s t <Double >>() ;

/ / C r e a t i n g an i n p u t l i s t

A r r a y L i s t <Double> i n p u t L i s t = s p a c e .

g e t L i n s p a c e ( −20 , 2 0 , p o i n t s ) ;

/ / A dding i n p u t l i s t t o i n p u t S t a c k

i n p u t S t a c k . add ( i n p u t L i s t ) ;

/ / E v a l u a t i n g i n p u t S t a c k w i t h

S i n g l e t o n −C e n t r o i d meth o d on f i s

f i s . e v a l u a t e F i s S i n g l e t o n C e n t r o i d (

i n p u t S t a c k , p o i n t s , andMethod ,

orMethod , impMethod , aggMethod ) ;

3 WATER TEMPERATURE AND

FLOW CONTROLLER TEST

CASE

To test the JT2FIS we going to use Water Temper-

ature and Flow Controller case. Water Temperature

and Flow Controller is a proposed problem that is

provided by Matlab as a example to show how to

use Fuzzy Logic Toolbox. Castro et. al. (Castro

et al., 2007) extends Matlab Toolbox to Type-2 Fuzzy

Logic, so we going to use this toolbox to compare our

approach with it.

We conﬁgured in the same way the Type-2 Fuzzy

Inference System using JT2FIS and Matlab Interval

Type-2 Fuzzy Toolbox.

The system implements the following rules:

1. If (Temp is Cold) and (Flow is Soft) then (Cold is

openSlow)(Hot is openFast)

2. If (Temp is Cold) and (Flow is Good) then (Cold

is closeSlow)(Hot is openSlow)

3. If (Temp is Cold) and (Flow is Hard) then (Cold

is closeFast)(Hot is closeSlow)

4. If (Temp is Good) and (Flow is Soft) then (Cold is

openSlow)(Hot is openSlow)

5. If (Temp is Good) and (Flow is Good) then (Cold

is Steady)(Hot is Steady)

6. If (Temp is Good) and (Flow is Hard) then (Cold

is closeSlow)(Hot is closeSlow)

7. If (Temp is Hot) and (Flow is Soft) then (Cold is

openFast)(Hot is openSlow)

Table 3: Inputs, Outputs example ”ISHOWER”.

Type MemberFunction Params

Input1 TrapaUncertaintyMemberFunction a1=-31,b1=-31,c1=-16,d1=-1,

a2=-29,b2=-29,c2=-14,d2=1.0,alfa=0.98

Input1 TriUncertaintyMemberFunction a1=-11,b1=-1,c1=9,a2=-9,b2=1,c2=11

Input1 TrapaUncertaintyMemberFunction a1=-1,b1=14,c1=29,d1=29,

a2=1,b2=16,c2=31,d2=31,alfa=0.98

Input2 TrapaUncertaintyMemberFunction a1=-3.1,b1=-3.1,c1=-0.9,d1=-0.1,

a2=-2.9,b2=-2.9,c2=-0.7,d2=0.1,alfa=0.98

Input2 TriUncertaintyMemberFunction a1=-0.45,b1=-0.05,c1=0.35,a2=-0.35,b2=0.05,c2=0.45

Input2 TrapaUncertaintyMemberFunction a1=-0.1,b1=0.7,c1=2.9,d1=0.1,

a2=0.9,b2=3.1,c2=3.1,d2=0.1,alfa=0.98

Output1 TriUncertaintyMemberFunction a1=-1.05,b1=-0.65,c1=-0.35,a2=-0.95,b2=-0.55,c2=-0.25

Output1 TriUncertaintyMemberFunction a1=-0.65,b1=-0.35,c1=-0.05,a2=-0.55,b2=-0.25,c2=0.05

Output1 TriUncertaintyMemberFunction a1=-0.35,b1=-0.05,c1=0.25,a2=-0.25,b2=0.05,c2=0.35

Output1 TriUncertaintyMemberFunction a1=-0.05,b1=0.25,c1=0.55,a2=0.05,b2=0.35,c2=0.65

Output1 TriUncertaintyMemberFunction a1=0.25,b1=0.55,c1=0.95,a2=0.35,b2=0.65,c2=1.05

Output2 TriUncertaintyMemberFunction a1=-1.05,b1=-0.65,c1=-0.35,a2=-0.95,b2=-0.55,c2=-0.25

Output2 TriUncertaintyMemberFunction a1=-0.65,b1=-0.35,c1=-0.05,a2=-0.55,b2=-0.25,c2=0.05

Output2 TriUncertaintyMemberFunction a1=-0.35,b1=-0.05,c1=0.25,a2=-0.25,b2=0.05,c2=0.35

Output2 TriUncertaintyMemberFunction a1=-0.05,b1=0.25,c1=0.55,a2=0.05,b2=0.35,c2=0.65

Output2 TriUncertaintyMemberFunction a1=0.25,b1=0.55,c1=0.95,a2=0.35,b2=0.65,c2=1.05

8. If (Temp is Hot) and (Flow is Good) then (Cold is

openSlow)(Hot is closeSlow)

9. If (Temp is Hot)and (Flow is Hard) then (Cold is

closeSlow)(Hot is closeFast)

3.1 JT2FIS Shower System Test Case

Results

With previous fuzzy inference system conﬁguration,

and using 101 points and Centroid reduction type, we

evaluate Water Temperature and Flow Controller in

JT2FIS and Matlab Interval Type-2 Fuzzy Toolbox

implementations. Table 4 show no difference between

tools obtaining the same response.

Table 5 show comparative performance between

tools with different discretizations points for in-

put1=20 and input2=1.

4 CONCLUSIONS

JT2FIS is an Object-Oriented Class Library for Build-

ing Java Intelligent Applications using Java Interval

Type-2 Fuzzy Inference System. We present architec-

ture and object oriented design of a JT2FIS class li-

brary. We provide an example of how to create and

conﬁgure an Interval Type-2 Fuzzy Inference Sys-

tem in Java and we show a Water Temperature and

ICEIS2013-15thInternationalConferenceonEnterpriseInformationSystems

528

Table 4: Comparing JT2FIS outputs versus Matlab



Inter-

val Type-2 Fuzzy Logic Toolbox outputs.

Inputs JT2FIS Interval Type-2 Fuzzy

Logic Toolbox

x1 x2 Output 1 Output 2 Time(ms) Output 1 Output 2 Time(ms)

-16 -0.8 0.3 0.6328 1 0.3 0.6328 8.6

-12 -0.6 0.3 0.6342 1 0.3 0.6342 8.6

-8 -0.4 0.2211 0.5184 1 0.2211 0.5184 8.6

-4 -0.2 -0.0098 0.2545 1 -0.0098 0.2545 8.6

0 0 0 0 1 0 0 8.6

4 0.2 0.0098 -0.2545 1 0.0098 -0.2545 8.6

8 0.4 -0.22113 -0.5184 1 -0.22113 -0.5184 8.6

12 0.6 -0.2999 -0.6342 1 -0.2999 -0.6342 8.6

16 0.8 -0.3 -0.6328 1 -0.3 -0.6328 8.6

20 1 -0.3 -0.6328 1 -0.3 -0.6328 8.6

Table 5: Comparing JT2FIS times(ms) versus Matlab



In-

terval Type-2 Fuzzy Logic Toolbox times(ms) with different

discretizations points for input1=20 and input2=1.

Number Points JT2FIS Interval Type-2 Fuzzy

Time(ms) Logic Toolbox Time(ms)

101 1 8.6

1001 8 13.7

10001 426 71.2

Flow Controller case of study to compare outputs re-

sponse between JT2FIS and Interval Type-2 Fuzzy

Logic Toolbox in Matlab.

ACKNOWLEDGEMENTS

The authors would like to thank to Universidad

Aut

onoma de Baja California (UABC) for grant this

project.

REFERENCES

Castillo, O., Melin, P., A.-G. A., Montiel, O., and

Sep

ulveda, R. (2011). Optimization of interval type-2

fuzzy logic controllers using evolutionary algorithms.

Soft Computing, 15(6):1145–1160.

Castillo, O. and Melin, P. (2008). Type-2 fuzzy logic. In

Type-2 Fuzzy Logic: Theory and Applications, vol-

ume 223 of Studies in Fuzziness and Soft Computing,

pages 29–43. Springer Berlin Heidelberg.

Castillo, O., Melin, P., and Castro, J. R. (2010). Computa-

tional intelligence software for interval type–2 fuzzy

logic. Journal Computer Applications in Engineering

Education.

Castro, J., Castillo, O., and Martinez, L. (2007). Inter-

val type-2 fuzzy logic toolbox. Engineering Letters,

15(1).

Castro, J., Castillo, O., Melin, P., and Rodr

ıguez-D

ıaz

(2009). A hybrid learning algorithm for a class

of interval type-2 fuzzy neural networks. Inf. Sci.,

179(13):2175–2193.

Cingolani, P. and Alcala-Fdez, J. (2012). jFuzzyLogic: a

robust and ﬂexible Fuzzy-Logic inference system lan-

guage implementation. 2012 IEEE International Con-

ference on Fuzzy Systems, pages 1–8.

Garc

ıa-Valdez, Licea-Sandoval, G., Alan

ız-Garza, A., and

Castillo, O. (2007). Object oriented design and imple-

mentation of an inference engine for fuzzy systems.

Engineering Notes, 15(1).

Jang, J., Sun, C., and Mizutani, E. (1997). Neuro-Fuzzy

and Soft Computing: A Computational Approach to

Learning and Machine Intelligence. MATLAB Cur-

riculum Series. Prentice Hall, Upper Saddle River, NJ.

Leal-Ram

ırez, C., Castillo, O., Melin, P., and Rodr

ıguez-

ıaz (2011). Simulation of the bird age-structured

population growth based on an interval type-2 fuzzy

cellular structure. Inf. Sci., 181(3):519–535.

Lucas, L. (2007). General Type-2 Fuzzy Inference Systems:

Analysis, Design and Computational Aspects. Fuzzy

Systems . . . , (5).

Melin, P., Mendoza, O., and Castillo, O. (2010). An

improved method for edge detection based on inter-

val type-2 fuzzy logic. Expert Systems Applications,

37(12):8527–8535.

Sep

ulveda, R., Castillo, O., Melin, P., and Montiel, O.

(2007). Analysis and Design of Intelligent Systems us-

ing Soft Computing Techniques, chapter An Efﬁcient

Computational Method to Implement Type-2 Fuzzy

Logic in Control Applications, pages 45–52.

Wagner, C. and Hagras, H. (2010). Fuzzy composite con-

cepts based on human reasoning. In IEEE Interna-

tional Conference on Information Reuse and Integra-

tion (IRI 2010), Las Vegas, Nevada, USA.

Zadeh, L. (1975). The concept of a linguistic variable and

its application to approximate reasoning. Information

Science, 8(199249):301–357.

Zadeh, L. A. (1965). Fuzzy Sets. Information and Control,

8:338–353.

Zadeh, L. a. (1973). Outline of a New Approach to

the Analysis of Complex Systems and Decision Pro-

cesses. IEEE Transactions on Systems, Man, and Cy-

bernetics, SMC-3(1):28–44.

JT2FIS:JavaType-2FuzzyInferenceSystem-AnObject-orientedClassLibraryforBuildingJavaIntelligentApplications

529