Current version: 1.03

Developed by Juan Rada-Vilela (jcrada@gmail.com). http://sites.google.com/site/jcrada

News

BUG FIX

(17/12/2011) There is a bug in fuzzylite on the TrapezoidalAlgorithm which causes results to be NaN. This can be fixed by changing it to TriangulationAlgorithm in the constructor of the FuzzyOperator.h. That is, use

const AreaCentroidAlgorithm* algorithm = new TriangulationAlgorithm, // instead of TrapezoidalAlgorithm

http://groups.google.com/group/fuzzylite NEW fuzzylite google group for dealing with problems compiling the fuzzylite and gui, as well as for features requests, and everything else! I have forwarded some emails I receive as well as some answers, if you do not find what you are looking for, please do not hesitate to email questions to the group :). Cheers, Juan.

Introduction

fuzzylite is a multiplatform, free, and open-source Fuzzy Inference System (FIS) written in C++ and released under the Apache License 2.0, which makes this software freely available for commercial and non-commercial use. The idea behind this FIS is to have a very simple and lite FIS. Simple as in simple to use, simple to understand, and simple to extend, without sacrificing performance. And lite because it requires no additional libraries more than the Standard Template Library included in the C++ Standard Library. It has an object-oriented approach and a clear separation between the headers and sources, so it is easy to extend. Furthermore, it is GUI-agnostic, meaning that the FIS does not require a GUI to run, encouraging its use as a library. Nevertheless, a Qt-based GUI is provided using fuzzylite as a shared library.

Example

An example of fuzzylite working in real-time

Features

• Linguistic terms are continuous and the following ones are available: triangular, trapezoidal, rectangular, shoulder, singleton, custom function, and compound (multiple functions).
• Export any fuzzy system to text using a slightly modified version of the Fuzzy Controller Language (FCL).
• Defuzzification using center of gravity (COG).
• Mamdani rule parsing with grammar checking.
• Takagi Sugeno rules of any order (e.g. f(x) = (sin x) / x, f(x) = 0.5 * input-1).
• Weights for each rule.
• TNorm: minimum, product, bounded difference.
• SNorm: maximum, sum, bounded sum.
• Modulation: clipping, scaling.
• Aggregation: maximum, sum, bounded sum.
• Variable sampling size for membership functions to compute area and centroid.
• Triangulation and Trapezoidal algorithms to compute the area and centroid.
• Hedges: not, somewhat, very, any.
• Very easy to implement and incorporate new linguistic terms, defuzzification methods, fuzzy rules (antecedents and consequents), fuzzy operations (T-Norms, S-Norms, methods for modulation and aggregation), algorithms for computing the area and centroid of linguistic terms, hedges, among other things.

What's new?

1.03

• Fixed makefiles of libraries to remove the main.h and main.cpp files from building in order to avoid problems when building certain configurations of projects.
• Bugs fixed in FuzzyOperation and CompoundTerm that caused some memory leaks. Courtesy of arash.abghari.

1.02

• Fixed the Triangulation Algorithm to include the first and last triangle (improved accuracy). Courtesy of rctaylor.
• Implemented the Trapezoidal Algorithm suggested by WHRoeder and used as default from now on.
• Created the scripts for building fuzzylite as static and dynamic library, as well as building a demo version of it. Tested on Linux Ubuntu and Mac OS X 10.5. Although the Unix version should work under Windows as well using g++.
• Added LeftShoulderTerm and RightShoulderTerm, just to provide a better understanding when configuring the FuzzyEngine.
• Changed all the #include <fuzzylite/?.h> for #include "fuzzylite/?.h".
• Included the Trapezoidal Algorithm into the GUI.

What's next?

• Make sure the scripts work for building fuzzylite in Windows environments.
• Fix the GUI so Takagi Sugeno rules can be tested with their respective graph.
• Improve the InfixToPostfix class so infix functions are parsed as one would normally expect.
• Load the fuzzy engine from text using the Fuzzy Controller Language (FCL).
• Include more linguistic terms (e.g. sigmoidal, gaussian, sine, cosine).
• Include more defuzzifiers (e.g. Right Most Maximum, Left Most Maximum, Mean Maximum).
• Make some functions inline to increase performance and check those that are already inline to ensure they do increase performance.

Known bugs

• InfixToPostfix conversion might not parse functions as one would normally expect. For example, sin (x) / x is not equivalent to (sin x) / x, the latter yields the result one might expect. Make sure by validating the postfix expression, or by evaluating its results.

• In the GUI, when using a Takagi Sugeno system, the output graphs do not work.

Building from source

fuzzylite 1.02

Inside ./fuzzylite there are 6 folders, on each there is a makefile. So all you have to do is execute from the folder the command make. The folders are described below (notice that [OS] stands for the operating system).

• [OS]-demo: Builds a demo version of fuzzylite which can be executed later as ./fuzzylite. It shows the results for four examples of Fuzzy Engines.
• [OS]-static: Builds the library as a static library (fuzzylite.a).
• [OS]-shared: Builds the library as a dynamic library (fuzzylite.so (unix) or fuzzylite.dylib (mac)).

This is a huge improvement from those really nasty NetBeans scripts. These scripts were automatically created by Eclipse.

Graphic User Interface

fuzzylite 1.02

In order to build this version, all you need to do (aside from having installed Nokia Qt) is execute from ./gui/ the command qmake. This will create a Makefile. Then, run make and it should start building the GUI. Notice that in gui.pro it links to the unix version of fuzzylite static library using relative path, so be sure to build such library first. If it is not unix what you need, perform your changes accordingly. In Mac OS X, you should run qmake -spec macx-g++ in order to create the Makefile.

Acknowledgements

This work was possible thanks to the Foundation for the Advancement of Soft Computing, to the Master of Soft Computing and Intelligent Data Analysis, and especially to Sergio Guadarrama and Luis Magdalena.