Softpedia >Windows >Programming >Components & Libraries >QtFuzzyLite >  Changelog

QtFuzzyLite Changelog

What's new in QtFuzzyLite 6.0

May 5, 2017
  • What’s New:
  • The FuzzyLite Libraries, namely fuzzylite and jfuzzylite, both in version 6.0, are licensed under the GNU General Public License version 3 and a private commercial license.
  • By default, fuzzylite builds using C++11 instead of C++98.
  • Important performance improvements.
  • Refactored the following names for the operation of engines: from activation operator to implication operator, from accumulation operator to aggregation operator.
  • Renamed the term Accumulated to Aggregated.
  • New activation methods decouple the activation of rules from the rule block and provide different methods for activating rules (see Activation Methods).
  • New class ActivationFactory provides a factory of activation methods.
  • New class Benchmark to evaluate the performance and accuracy of engines.
  • New class Complexity to estimate the computational complexity of an engine.
  • New class RScriptExporter to export the surfaces of an engine using the ggplot2 library.
  • New class Binary term for binary edges.
  • New UnboundedSum S-Norm in SNormFactory.
  • New classes SNormFunction and TNormFunction to create custom functions on any two values using the Function class.
  • Added description strings to Engine, Variable and RuleBlock
  • Privatized previously protected members of classes and subclasses of Term, Variable, Rule, Defuzzifier, [Cloning|Construction]Factory, Importer, Exporter, amongst others.
  • Improved portability by replacing int for std::size_t where necessary, thereby additionally removing warnings in Windows 64bit
  • Deleted Operation.cpp and inlined its methods into Operation.h
  • Updated .travis.yml to use Docker, and build using g++ (versions 6, 5, 4.9, 4.8, 4.7) and clang (versions 3.8, 3.7, 3.6, and 3.5).
  • Added appveyor.yml to use continuous integration in Windows under Visual Studio 2013 and 2015.
  • Added some unit tests and support for future unit tests.
  • Bug fixes.
  • New example of hybrid engines.
  • New example on obstacle avoidance for Mamdani, Takagi-Sugeno, and Hybrid engines.
  • New R scripts for each example and its respective surfaces in pdf formats.
  • Bug fixes:
  • Fixed bug in CloningFactory::deregisterObject(). Bug: Object was deleted before removing it from the map, leaving an invalid object in the map which would cause a segmentation fault. Solution: Remove the object from the map before deleting it.
  • Fixed bug causing segmentation fault when malformed term in FuzzyLite Language
  • Fixed bug computing the NormalizedSum S-Norm.
  • Fixed bug in RuleBlock to reset and clone the implication operator. Bug: implication operator is not copied and reset. Fix: copy and reset implication operator when cloning the RuleBlock.
  • Fixed bug in Function term. Bug: given a formula = “tan(y)” and a map[“y”] = 1.0, and executing Function::load(formula), then the map of variables is reset because load() calls unload() first, causing the deregistration of variable y. Solution: Removed method unload() from load(), thereby causing future load() not to reset variables.
  • Fixed bug in Function when enclosing variable in double parenthesis.

New in QtFuzzyLite 5.0b1408 (Aug 9, 2014)

  • General:
  • fuzzylite v5.0 is dual-licensed under the GNU LGPL v3.0 and a paid commercial license.
  • Support for both C++98 and C++11 using the latest features.
  • Support for multiple compilers g++, Clang, MSVC.
  • Refactoring of many classes to improve design and performance.
  • Performance improvements of Takagi-Sugeno controllers by over 55% with respect to v4.0 (estimate based on the average performance on the examples included).
  • Smart pointers in many classes take care of automatically deleting objects when setting new pointers (Accumulated, FactoryManager, Function, OutputVariable, Rule, and RuleBlock).
  • Exceptions are thrown when any of the following RuleBlock::[conjunction|disjunction|activation], Accumulated::accumulation, and OutputVariable::defuzzifier are required but set to fl::null, thereby replacing the operations that would lead to [signal 11] Segmentation fault to operations that throw a fl::Exception instead.
  • Automatic build script to build fuzzylite in debug and release mode.
  • Binaries of debug libraries are renamed to append the letter d (e.g.,fuzzylited.dll, libfuzzylited.so).
  • New file fuzzylite/src/m/compare.m to compare the output values of your fuzzylite engines with the evaluation of the same engine in Octave/Matlab.
  • There is practically no difference between the output values obtained with fuzzylite and those obtained with Octave/Matlab. Based on the examples, the average mean square error (MSE) between the output values is less than 7.3e-12 (or 0.0000000000073) due to negligible differences in floating-point arithmetic. The results and comparison can be found in examples/examples.mat .
  • Source code of applications based on version 4.0 will most likely not compile with version 5.0.
  • Minor bugs and memory leaks fixed.
  • Macros:
  • Added support for C++11 with smart pointers, method identifiers, move constructors and move operators as follows. For precise information, refer to file fuzzylite/fl/fuzzylite.h.
  • Macros for identifiers are defined as FL_IOVERRIDE override, FL_IFINAL final, FL_IDEFAULT = default, FL_IDELETE = delete, FL_INOEXCEPT noexcept, FL_DEFAULT_COPY(Class), FL_DEFAULT_MOVE(Class), and FL_DEFAULT_COPY_AND_MOVE(Class).
  • Added macro FL_unique_ptr to refer to std::auto_ptr (C++98) or std::unique_ptr (C++11), and its respective FL_move_ptr(x) to move a smart pointer, albeit FL_move_ptr(x) is not used within the library as it is not needed.
  • Added global variables const long fl::null = 0L to refer to the null pointer in C++98 and const std::nullptr_t null = nullptr to refer to the null pointer in C++11.
  • Renamed macro FL_DEBUG to FL_DBG.
  • Renamed macros FL_BEGIN_DEBUG_BLOCK and FL_END_DEBUG_BLOCK to FL_DEBUG_BEGIN and FL_DEBUG_END, respectively.
  • Renamed macro FL_EXPORT to FL_API
  • Added macro definitions FL_EXPORT_LIBRARY and FL_IMPORT_LIBRARY. If you are building fuzzylite as a shared library, you need to define FL_EXPORT_LIBRARY. If you are building fuzzylite executable and it utilizes the fuzzylite shared library, you need to define FL_IMPORT_LIBRARY. If you are building fuzzylite as a static library and/or building fuzzylite executable using the fuzzylite static library, then you do not need to define either FL_[IMPORT|EXPORT]_LIBRARY. Note that the same conditions apply for your application. This is particularly important in Windows platforms, as FL_IMPORT_LIBRARY and FL_EXPORT_LIBRARY define FL_API to __declspec(dllimport) and __declspec(dllexport), respectively. If in doubt, please check fuzzylite/CMakeLists.txt
  • Operation:
  • Added method Operation::toScalar(std::string x, scalar alternative) FL_INOEXCEPT which returns alternative if x is not a valid scalar, and never throws an exception.
  • Added method Operation::toScalar(std::string x) that returns the scalar value of x or throws a fl::Exception if x is not a valid scalar.
  • Marked method (from v4.0) Operation::toScalar(std::string, bool, scalar) FL_IDELETE; and removed its implementation such that its usage is prevented at compile time in C++11 and at linker time in C++98. Please, use the appropriate Op::toScalar methods mentioned above.
  • Renamed method Op::isNan to Op::isNaN.
  • Added method fl::Op::isFinite(x) which returns not (isNaN(x) or isInf(x)).
  • Changed fl::Op::isEq(a,b) to return true if a == b == NaN.
  • Changed fl::Op::isEq(a,b) to return true if a == b == Inf.
  • Changes to fl::Op::isEq affect other comparison methods fl::Op::is[Lt|LEq|GEq|Gt].
  • Added shortcuts of comparisons fl::Op::[gt,lt,ge,le,eq,neq](scalar a, scalar b), mostly to provide binary versions (without macheps) for term Function.
  • Deleted method Op::repeat.
  • Removed method fuzzylite::configuration().
  • Changed default fuzzylite::_macheps = 1e-6;.
  • Renamed method Op::makeValidId to Op::validName, which now returns "unnamed" for empty strings.
  • Engine:
  • Moved Engine::hedges (and relevant methods) to Rule::hedges.
  • Added enumeration for the type of engine: enum Engine::Type{Mamdani, Larsen, TakagiSugeno, Tsukamoto, InverseTsukamoto, Hybrid, Unknown}.
  • Added method Type Engine::type(std::string* name, std::string* reason) to infer the type of the engine based on its configuration, additionally provides the name of the type and the inference reasons for its type.
  • Changed method Engine::isReady(std::string) to satisfy the default operation of controllers. The method Engine::isReady(std::string) was initially conceived to provide information before a potential [signal 11] Segmentation fault happened due to improper configuration. However, given the improved handling of signals and exceptions mentioned in Section General, using method Engine::isReady(std::string) is not necessary except for providing suggestions of what could potentially cause an error.
  • Added methods Engine::set[Input|Output]Variables(std::vector) and Engine::setRuleBlocks(std::vector).
  • Added methods Engine::[input|output]Variables() and Engine::ruleBlocks() to return mutable references.
  • Added method Engine::variables() to retrieve a vector (copy) containing the InputVariables followed by the OutputVariables.
  • Added method Engine::updateReferences() to update the references to the engine in all the necessary linguistic terms (i.e., Linear and Function).
  • Added method Engine::clone().
  • Added copy constructors, assignment operators, and default move constructor to Engine.
  • Input and Output Variables:
  • Added methods OutputVariable::[get|set]OutputValue() to [retrieve|store] value from defuzzification
  • Changed return type of scalar OutputVariable::defuzzify() to void OutputVariable::defuzzify() because now it automatically stores the defuzzified output value, and also stores the previous valid output value regardless of locks. Like in version 4.0, if OutputVariable::lockPreviousOutputValue=true, and the defuzzified output value is not valid (i.e., [NaN|Inf]) or no rules were activated, then the defuzzified output value is replaced for the previous valid output value.
  • Removed method OutputVariable::defuzzifyNoLocks().
  • Renamed variable OutputVariable::lastValidOutputValue to OutputVariable::previousOutputValue.
  • Renamed method OutputVariable::[get|set]LastValidOutput() to OutputVariable::[get|set]PreviousOutputValue().
  • Renamed variable OutputVariable::lockValidOutput to OutputVariable::lockPreviousOutputValue.
  • Renamed method OutputVariable::setLockValidOutput() to OutputVariable::setLockPreviousOutputValue().
  • Renamed method OutputVariable::isLockingValidOutput() to OutputVariable::isLockedPreviousOutputValue().
  • Renamed variable OutputVariable::lockOutputRange to OutputVariable::lockOutputValueInRange.
  • Renamed method OutputVariable::setLockOutputRange() to OutputVariable::setLockOutputValueInRange().
  • Renamed method OutputVariable::isLockingOutputRange() to OutputVariable::isLockedOutputValueInRange().
  • Added methods std::string InputVariable::fuzzyInputValue() and std::string OutputVariable::fuzzyOutputValue().
  • Added method OutputVariable::clear() to clear the fuzzy output, and set OutputVariable::previousOutputValue = fl::nan and set OutputVariable::outputValue = fl::nan.
  • Added copy constructors, assignment operators, move constructors and move operators to [Input|Output]Variable.
  • Added method Variable::terms() to return mutable reference.
  • Changed OutputVariable::[defuzzifier|fuzzyOutput] to smart pointers (FL_unique_ptr).
  • Linguistic Terms:
  • Added method Term::[get|set]Height to define the height of integral terms, and multiply their respective membership functions accordingly.
  • Added copy constructors, assignment operators, move constructors and move operators to every Term.
  • Parameters of all terms are set by default to fl::nan.
  • Renamed method Term::copy() to Term::clone() in every Term.
  • Added method Term::updateReference(Term*, Engine*) to ensure Linear and Function terms have updated pointers to the Engine (useful when cloning and copy-constructing).
  • Added linguistic terms Concave, Cosine and Spike.
  • Changed Accumulated to take Activated* terms instead of const Terms*.
  • Removed const from return type of method SNorm* Accumulated::[get|set]Accumulation().
  • Changed Accumulated::accumulation to a smart pointer (FL_unique_ptr).
  • Added method Accumulated::terms() to return mutable reference.
  • Renamed methods Triangle::[set|get][A|B|C] to ::[set|get]Vertex[A|B|C].
  • Renamed methods Trapezoid::[set|get][A|B|C|D] to ::[set|get]Vertex[A|B|C|D].
  • Renamed term Thresholded to Activated.
  • Renamed methods Thresholded::[set|get]Threshold() to Activated::[set|get]Degree().
  • Added enumeration [Ramp|Sigmoid]::Direction{ NEGATIVE, ZERO, POSITIVE } to refer to the slope.
  • Added methods Ramp::direction() and Sigmoid::direction() to retrieve direction of slope.
  • Removed Exception Specification from methods in Discrete, Linear and Function terms.
  • Linear and Discrete Terms:
  • Changed Linear from having pointers to the input variables to having a pointer to the Engine.
  • Changed visibility of Linear::coefficients to protected.
  • Added methods Linear::coefficients(), Linear::setCoefficients().
  • Linear term no longer throws exception when inputVariables != |coefficients|.
  • Removed public vector of variables Discrete::[x|y].
  • Added a typedef std::pair Discrete::Pair.
  • Changed representation of Discrete::[x|y] from std::vector to std::vector.
  • Added methods Discrete::setXY() and Discrete::xy() to set and get the new representation of pairs.
  • Added methods Discrete::xy(int index) to retrieve Discrete::Pair at index.
  • Added methods Discrete::toPairs(std::vector) which throws an exception if the vector is missing a value (i.e., std::vector.size() % 2 != 0), and Discrete::toPairs(std::vector, scalar missingValue) which adds missingValue in case std::vector.size() %2 == 1, hence never throwing an exception.
  • Added method Discrete::toVector(std::vector) to convert std::vector to a std::vector.
  • Added method Discrete::formatXY() to get pairs (x,y) nicely formatted.
  • Function Term:
  • Merged structs Function::Operator and Function::BuiltInFunction into a single struct Function::Element.
  • Changed the precedence of all built-in instances of Function::Element of type Operator starting from 100 and decreasing by 10. The precedence of built-in operators is the following: (100) Logical not [!] and Negation [~]; (90) Power [^]; (80) Multiplication [*], Division [/] and Modulo [%]; (70) Addition [+] and Subtraction [-]; (60) Logical AND [and] and Logical OR [or]. If you have registered your own operators, please adjust their precedence as required.
  • Added to Function built-in comparison functions gt,lt,ge,le,eq and operator logical not !.
  • Modified typedefs Function::Unary and Function::Binary to take scalar instead of double.
  • Changed public Function::root to protected Function::_root and it is now a smart pointer (FL_unique_ptr).
  • Added method Function::root() to return pointer to Function::root.
  • Moved built-in functions and operators from Function to a FunctionFactory.
  • [T|S]Norms and Hedges:
  • Fixed operation when using multiple hedges to operate from right-most to left-most, e.g. if Ambient is not very extremely bright, now evaluates as follows not(very(extremely(bright))).
  • Added TNorm nilpotent minimum and SNorm nilpotent maximum.
  • Added clone methods to every Norm.
  • Added clone methods to every Hedge.
  • Moved Engine::hedges to Rule::hedges.
  • Rules:
  • Moved Engine::hedges (and methods) to Rule::hedges.
  • Added method Rule::isLoaded() to determine whether a rule was properly parsed and thus can be activated.
  • Added method Rule::unload() to allow the existence of a rule in an inactive state (useful for invalid rules).
  • Removed variable Rule::FL_ASSIGNS and method Rule::assignsKeyword(), for which the symbol = in rules is no longer valid.
  • Changed visibility of method Rule::setText() to public.
  • Added method Rule::load(const Engine*).
  • Changed Rule::[antecedent|consequent] to smart pointers (FL_unique_ptr).
  • Renamed method Antecedent::[get|set]Root() to Antecedent::[get|set]Expression().
  • Added methods [Antecedent|Consequent]::[get|set]Text().
  • Added methods [Antecedent|Consequent]::[load|unload](), with the same objective as Rule::[load|unload]().
  • Rule Blocks:
  • Added method RuleBlock::reloadRules().
  • Added method RuleBlock::setRules(std::vector).
  • Added method RuleBlock::rules() to return mutable reference.
  • Removed const from TNorm and SNorm in RuleBlock::[get|set][Conjunction|Disjunction|Activation](), respectively.
  • Changed RuleBlock::[conjunction|disjunction|activation] to smart pointers (FL_unique_ptr).
  • Added basic rule chaining such that an OutputVariable can be utilized in the Antecedent of a Rule. For example, considering the rule if Power is high then InversePower is low, where Power and InversePower are both output variables, the activation degree of the Antecedent will correspond to the accumulated activation degree of the term high in the fuzzy output of Power. If Power::accumulation = none, the accumulated activation degree of the term high will be computed as the regular sum of the activation degrees of term high in the fuzzy output of Power. Otherwise, the accumulated activation degree is computed utilizing the Power::accumulation operator.
  • Weighted Defuzzifiers:
  • Added copy constructors, assignment operators, move constructors and move operators.
  • Added method Defuzzifier::clone().
  • Performance improvements of Takagi-Sugeno controllers by over 55% (with respect to v4.0) based on the average performance on the examples included.
  • Created class WeightedDefuzzifier from which classes Weighted[Average|Sum] are derived.
  • Added enumeration WeightedDefuzzifier::Type{Automatic, TakagiSugeno, Tsukamoto} and respective methods WeightedDefuzzifier::[get|set]Type() and WeightedDefuzzifer::getTypeName().
  • Added method WeightedDefuzzifier::inferType(Term*) to automatically determine the WeightedDefuzzifier::Type based on the class of Term.
  • By default, WeightedDefuzzifier::type = Automatic, which automatically infers the type based on the WeightedDefuzzifier::inferType().
  • There is a small performance penalty when using WeightedDefuzzifier::type = Automatic because WeightedDefuzzifier::inferType() performs three dynamic_cast.
  • Deleted class Tsukamoto. Its method static tsukamoto() was moved to virtual WeightedDefuzzifier::tsukamoto(), which allows to be overriden
  • Added support for Tsukamoto with Concave terms.
  • In version 5.0, the traditional operation of Takagi-Sugeno and Tsukamoto controllers is achieved by setting OutputVariable::accumulation = none. Unlike version 4.0, the RuleBlock::activation will not have any effect on Takagi-Sugeno nor Tsukamoto controllers, for which RuleBlock::activation should also be set to none. More information about the roles of the OutputVariable::accumulation and RuleBlock::activation operators are detailed as follows.
  • In version 5.0, the role of the RuleBlock::activation TNorm on the Weighted[Average|Sum] always performs a regular multiplication of the weights and the values (i.e., wi×zj) regardless of the TNorm chosen. In other words, selecting any RuleBlock::activation for Weighted[Average|Sum] is irrelevant, and should be set to none as every TNorm will have the same multiplication effect. This operation is different from fuzzylite version 4.0, where the RuleBlock::activation operator was utilized to multiply the weights and values (i.e. wi⊗zj), and therefore the traditional operation of the Weighted[Average|Sum] was achieved when RuleBlock::activation = AlgebraicProduct;.
  • In version 5.0, the role of the OutputVariable::accumulation = none on the Weighted[Average|Sum] results in a regular sum of the multiplied weights and values, i.e., ∑niwi×zj∑niwi. However, if the OutputVariable::accumulation != none, the role of the SNorm will be to accumulate the activation degrees of the repeated terms in the fuzzy output of the variable. For example, considering the rules if Ambient is dark then Power is high and if Ambient is medium then Power is high, for any input value of Ambient that activates both rules, the fuzzy output of Power will have the term high activated with the degree from Rule 1, and the term high activated with the degree from Rule 2. Since the term high appears twice in the fuzzy output, the role of the accumulation operator will be to accumulate the activation degree of high resulting in (w1⊕w2)×zhigh(w1⊕w2). If another term were activated, the result would be (w1⊕w2)×zhigh+wi×zj(w1⊕w2)+wi. In version 4.0, the accumulation operator had no effect on the Weighted[Average|Sum].
  • Integral Defuzzifiers:
  • Added copy constructors, assignment operators, move constructors and move operators.
  • Added method Defuzzifier::clone().
  • Proper handling of indefinite integral defuzzification, that is, returning fl::nan when [minimum|maximum]=[NaN|Inf].
  • Default resolution of integration is defined as static int IntegralDefuzzifier::defaultResolution=200, and can be changed via static IntegralDefuzzifier::setDefaultResolution().
  • In fuzzylite, the accumulation operator has been for several versions associated with the output variables and not with the rule blocks, despite that the FCL format and other fuzzy logic control libraries associate the accumulation operator with the rule blocks. The argument for such a decision is that fuzzylite provides coherent support for multiple rule blocks operating on the same engine and on the same output variables. For example, if multiple rule blocks operate on the same output variables, it only makes sense to have a single accumulation operator associated with each output variable such that the defuzzifier can naturally operate over the accumulated fuzzy output. Differently, if the accumulation operator were associated with the rule block, the possibility of having different accumulation operators in different rule blocks questions (1) the possibility of having multiple rule blocks operating over the same output variables; and (2) the usage of different accumulation operators over the accumulation and defuzzification processes. Certainly, if (1) is not possible, i.e, different rule blocks only operate on different output variables, then (2) is not a problem because the accumulation process and defuzzification of each variable will only have a single accumulation operator. It is therefore that the association of the accumulation operator with the output variable in fuzzylite provides a better design and an additional feature that allows having multiple rule blocks operating over the same output variables.
  • Importers and exporters:
  • Since terms have a new height property, [Fll|Fis|Fcl]Exporter exports terms with an additional scalar at the end, which indicates the height of the term. However, if height=1.0, the additional scalar is not exported.
  • In [Fll|Fis|Fcl]Importer, when importing terms, if there is an additional scalar it will be assumed as the height of the term. For example, term: high Gaussian 1.0 0.5 0.75 will create a Gaussian term with mean 1.0, standard deviation 0.5 and height 0.75. This is extremely important because there are some examples from Matlab in fis format that append a useless 0.0 to some terms.
  • In FisExporter, if the Takagi-Sugeno controller has no activation or accumulation operators (as it should generally be the case), Octave and Matlab will not be able to import the fis file. To overcome this issue, you will have to set ImpMethod="min" and AggMethod="max", where ImpMethod and AggMethod are just dummy operators that can be set to any TNorm and SNorm, respectively.
  • Improved compatibility of the exported code obtained with [Fis|Fcl]Exporter by exporting the additional features of fuzzylite only when these are different from the default operation. For example, the following features will not be exported given their values: [Input|Output]Variable::enabled = true;, OutputVariable::lock-previous = false;, OutputVariable::lock-range = false;, amongst others.
  • Renamed FLL property 'lock-valid' to 'lock-previous'.
  • Renamed FIS property 'LockValid' to 'LockPrevious'.
  • Renamed FCL property 'LOCK: VALID' to 'LOCK: PREVIOUS'.
  • Export your controllers to files using [Fll|Fld|Fis|Fcl]Exporter::toFile().
  • Import your controllers from files using [Fll|Fis|Fcl]Importer::fromFile().
  • FldExporter exports the FuzzyLite Dataset of an engine utilizing the input values of another FuzzyLite Dataset.
  • FldExporter no longer restarts the engine when exporting.
  • Renamed method FldExporter::toWriter() to FldExporter::write().
  • Removed variable and methods for property int FldExporter::_maximum.
  • Added option in CppExporter to prepend the namespace prefix fl:: to the classes, and by default it does not prepend prefix.
  • Improvement accuracy of FisImporter when importing fis files whose scalar values have more than three decimal numbers.
  • Renamed methods in [Fis|Fcl]Importer::extract* to [Fis|Fcl]Importer::parse*.
  • Factories:
  • Created a generic CloningFactory to create clones of objects.
  • Created FunctionFactory based on CloningFactory where function operators and methods are stored to be cloned as necessary by Function. Additional functions and operators can be easily registered.
  • Moved built-in functions and operators from Function to FunctionFactory.
  • Renamed methods Factory::[register|deregister]Class() to Factory::[register|deregister]Constructor().
  • Renamed Factory to ConstructionFactory.
  • Renamed typedef Factory::Creator to typedef Factory::Constructor.
  • Changed pointers of FactoryManager to smart pointers (FL_unique_ptr).
  • Examples:
  • Added two examples for basic rule chaining: mamdani/SimpleDimmerInverse.fll and mamdani/Laundry.fll.
  • Included the original example files in fis format.
  • Added conversion of examples/original/*.fis to examples/original/*.fll.
  • Modified original/takagi-sugeno examples to reflect activation: none; accumulation: none;.
  • Updated FLD examples produced from the original examples.
  • Added file fuzzylite/src/m/compare.m to compare the output values of your fuzzylite engines with the evaluation of the same engine in Octave/Matlab.
  • Added file examples/examples.mat containing the comparison of the output values between fuzzylite and Matlab’s Fuzzy Logic Toolbox.
  • Added code to perform benchmarks in Linux.
  • Console:
  • Console includes option to import custom input dataset from file an export its respective output values.
  • Created the FuzzyLite Interactive Console, which can be started by specifying an input file and the output format, e.g., fuzzylite -i SimpleDimmer.fll -of fld.
  • Console provides more information about its usage.
  • Fixed bugs and leaks:
  • Fixed operation when using multiple hedges to operate from right-most to left-most, e.g. if Ambient is not very extremely bright evaluates as follows not(very(extremely(bright))).
  • Fixed membership functions of specific cases of Triangle when a=b or b=c, and Trapezoid when a=b or c=d.
  • Fixed minor memory leak at ~RuleBlock::[conjunction|disjunction|activation].
  • Fixed minor memory leak at ~Accumulated::accumulation.
  • Fixed minor memory leak at ~OutputVariable::defuzzifier.
  • Fixed minor memory leak at ~Function::Node.
  • Fixed minor memory leak at ~FactoryManager::[factories].
  • Fixed some rethrowing of exceptions to provide proper information about errors. Specifically, changed some rethrown exceptions from throw ex; to just throw;
  • Fixed building using -DFL_USE_FLOAT=ON
  • Term Editor:
  • Completely redesigned Term Editor.
  • Terms: Concave, Cosine and Spike.
  • Live editing of Discrete and Function.
  • Significantly improved Cloning of terms: Manual, Range, Symmetric, Next Term; Swapping terms.
  • Tooltips showing coordinates, and Vertical and Horizontal guides.
  • Surface 2D
  • Type of Engine and the inference reasons.
  • Option to visualize y~ or μ(y) in Output Variables.
  • A redesigned Rule Editor with live editing.
  • Redesigned FldExporter that allows: exporting a specific number of results over the variables range, export from a custom FuzzyLite Dataset, and save results to files. Plus, export headers, input values and output values.
  • Option to export to C++ without using the namespaces.
  • QtFuzzyLite.ini to customize many aspects such as number of decimals, look and feel, confirm quit, resolution of defuzzifiers, window geometry, graphics resolutions, show templates of importing.
  • Improved check for updates.
  • Natural support for NaN and Inf values as input values and ranges.
  • A lot more visual information.

New in QtFuzzyLite 3.1b1309 (Nov 6, 2013)

  • Included Tsukamoto controllers and fixed bugs

New in QtFuzzyLite 3.0b1307 (Jul 22, 2013)

  • Takagi-Sugeno controller with Constant, Linear, and Function terms
  • Over 20 Takagi-Sugeno examples from Matlab and Octave
  • Function term allows you to create any function utilizing the inputs and outputs of your engine
  • Bisector defuzzifier
  • Unified rule parsing for Mamdani and Takagi-Sugeno via FuzzyRule
  • Engine::isReady(std::string*) checks for common mistakes setting up the engine
  • Constants fl::nan and fl::inf to refer to not-a-number and infinity
  • Bug fixes