| 1 |
Version 6.0 |
| 2 |
=========== |
| 3 |
|
| 4 |
Overview |
| 5 |
-------- |
| 6 |
* The FuzzyLite Libraries, namely fuzzylite and jfuzzylite, both in version 6.0, are licensed under the GNU General Public License version 3. |
| 7 |
|
| 8 |
* By default, fuzzylite builds using C++11 instead of C++98. |
| 9 |
|
| 10 |
* Important performance improvements. |
| 11 |
|
| 12 |
* Refactored the following names for the operation of engines: from activation operator to implication operator, from accumulation operator to aggregation operator. |
| 13 |
|
| 14 |
* Renamed the term `Accumulated` to `Aggregated`. |
| 15 |
|
| 16 |
* New activation methods decouple the activation of rules from the rule block and provide different methods for activating rules (see Activation Methods). |
| 17 |
|
| 18 |
* New class `ActivationFactory` provides a factory of activation methods. |
| 19 |
|
| 20 |
* New class `Benchmark` to evaluate the performance and accuracy of engines. |
| 21 |
|
| 22 |
* New class `Complexity` to estimate the computational complexity of an engine. |
| 23 |
|
| 24 |
* New class `RScriptExporter` to export the surfaces of an engine using the `ggplot2` library. |
| 25 |
|
| 26 |
* New class `Binary` term for binary edges. |
| 27 |
|
| 28 |
* New `UnboundedSum` S-Norm in `SNormFactory`. |
| 29 |
|
| 30 |
* New classes `SNormFunction` and `TNormFunction` to create custom functions on any two values using the `Function` class. |
| 31 |
|
| 32 |
* Added description strings to `Engine`, `Variable` and `RuleBlock` |
| 33 |
|
| 34 |
* Privatized previously protected members of classes and subclasses of `Term`, `Variable`, `Rule`, `Defuzzifier`, `[Cloning|Construction]Factory`, `Importer`, `Exporter`, amongst others. |
| 35 |
|
| 36 |
* Improved portability by replacing `int` for `std::size_t` where necessary, thereby additionally removing warnings in Windows 64bit |
| 37 |
|
| 38 |
* Deleted `Operation.cpp` and inlined its methods into `Operation.h` |
| 39 |
|
| 40 |
* 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). |
| 41 |
|
| 42 |
* Added `appveyor.yml` to use continuous integration in Windows under Visual Studio 2013 and 2015. |
| 43 |
|
| 44 |
* Added some unit tests and support for future unit tests. |
| 45 |
|
| 46 |
* Bug fixes. |
| 47 |
|
| 48 |
* New example of hybrid engines. |
| 49 |
|
| 50 |
* New example on obstacle avoidance for Mamdani, Takagi-Sugeno, and Hybrid engines. |
| 51 |
|
| 52 |
* New R scripts for each example and its respective surfaces in `pdf` formats. |
| 53 |
|
| 54 |
|
| 55 |
Activation Method |
| 56 |
----------------- |
| 57 |
* New activation methods determine the activation of rules in a rule block. Specifically, the activation methods compute the activation degrees of the rules and the activation order of the rules. |
| 58 |
|
| 59 |
* Seven activation methods available: General, First, Last, Highest, Lowest, Proportional and Threshold. |
| 60 |
|
| 61 |
* If no activation method is supplied, an instance of General will be automatically set. |
| 62 |
|
| 63 |
* New class `General` activates every rule following the insertion order in the rule block. |
| 64 |
|
| 65 |
* New classes `First` and `Last` activate the first and last $n$ rules (following insertion order) whose activation degrees are greater than or equal to a given threshold. |
| 66 |
|
| 67 |
* New classes `Highest` and `Lowest` activate the first and last $n$ rules sorted (descending or ascending) by activation degree. |
| 68 |
|
| 69 |
* New class `Proportional` activates every rule with an activation degree proportional to the activation degrees of the other rules. |
| 70 |
|
| 71 |
* New class `Threshold` activates every rule that satisfies a given comparison operator and a given threshold. |
| 72 |
|
| 73 |
* New class `ActivationFactory` provides a factory of activation methods. |
| 74 |
|
| 75 |
|
| 76 |
|
| 77 |
Defuzzifier |
| 78 |
----------- |
| 79 |
* Overall performance improvements |
| 80 |
* The new default resolution of integral defuzzifiers is 100 (from 200 in previous version) |
| 81 |
* Importantly simplified `WeightedAverage` and `WeightedSum` by not using the implication and aggregation operators. |
| 82 |
* New experimental classes `WeightedAverageCustom` and `WeightedSumCustom` which use the implication and aggregation operators to compute the weighted averages and weighted sums, respectively. |
| 83 |
|
| 84 |
|
| 85 |
Factory |
| 86 |
------- |
| 87 |
* New class `ActivationFactory` to register activation methods. |
| 88 |
* New method `FactoryManager::activation()` to get the activation factory. |
| 89 |
* Inlined methods in [CloningFactory|ConstructionFactory].h |
| 90 |
* 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. |
| 91 |
* New `abs` function in `FunctionFactory` to compute the absolute value of a number. |
| 92 |
* New `UnboundedSum` S-Norm in `SNormFactory`. |
| 93 |
|
| 94 |
Hedge |
| 95 |
----- |
| 96 |
* Added `FL_IOVERRIDE` identifiers to hedge Extremely |
| 97 |
* Added `FL_IFINAL` final identifiers to `Hedge` classes (except `Any`). |
| 98 |
|
| 99 |
|
| 100 |
|
| 101 |
Importer and Exporter |
| 102 |
--------------------- |
| 103 |
* New `RScriptExporter` generates an R script that uses the `ggplot2` library to produce the surfaces of an engine for each pair of input variables on each output variable. |
| 104 |
|
| 105 |
* Updated `Fll[Importer|Exporter]` to import and export the newly named properties `implication` and `aggregation` (previously known as `activation` and `accumulation`). However, the `FllImporter` has backward compatibility with the previous property names. |
| 106 |
|
| 107 |
* In `Fll[Importer|Exporter]`, added `lock-range` property of input variables, `activation` property for activation methods in rule blocks, and `description` property to `[Input|Output]Variable` and `RuleBlock`. |
| 108 |
|
| 109 |
* Added default option to generate C++ and Java code using the actual names of the input variables, output variables, and rule blocks, instead of the generic `[input|output]Variable` and `ruleBlock` names. |
| 110 |
|
| 111 |
* Updated [Cpp|Java][Import|Export] to generate code using the `description` of an engine if available, the `implication` instead of the `activation`, and the `aggregation` instead of the `accumulation`. |
| 112 |
|
| 113 |
* Removed compatibility between `[Fcl|Fis]Exporter` and `fuzzylite`. In previous versions, these exporters produced additional tags that were only relevant to `fuzzylite`, so that an engine written in these languages could also support the features in `fuzzylite`. However, in doing so, Matlab, Octave and JFuzzyLogic would fail to import the engines written in their own languages because they would not recognize the `fuzzylite` features. Hence, in order to generate code compatible with Matlab, Octave, and JFuzzyLogic, the `fuzzylite` features are removed from the code. |
| 114 |
|
| 115 |
* Refactored methods [Cpp|Java|Fll|Fis|Fcl]Exporter::toString([S|T]Norm*) to take `::toString(Norm*)`. |
| 116 |
|
| 117 |
* Renamed methods FisImporter::extract[SNorm|TNorm|Defuzzifier]() to FisImporter::translate[SNorm|TNorm|Defuzzifier]() |
| 118 |
|
| 119 |
* Fixed bug causing segmentation fault when malformed term in FuzzyLite Language |
| 120 |
|
| 121 |
|
| 122 |
|
| 123 |
Norms |
| 124 |
----- |
| 125 |
* New class `UnboundedSum` to compute sum between any two values and hence reflect Matlab's and Octave's `sum` aggregation operator. |
| 126 |
* New classes `SNormFunction` and `TNormFunction` to create custom functions on any two values using the `Function` class. |
| 127 |
* Fixed bug computing the `NormalizedSum` S-Norm. |
| 128 |
|
| 129 |
|
| 130 |
Rule |
| 131 |
---- |
| 132 |
* Added properties `fl::scalar activationDegree`, `bool triggered` and `bool enabled` to a `Rule`. The `activationDegree` property stores the activation degree of the rule in order to avoid recomputing it when requesting it. The `triggered` property indicates whether the rule was triggered (i.e., whether the antecedent modified the consequent). The `enabled` property determines whether the rule can be triggered (by default, a rule is always enabled unless programmatically indicated otherwise). |
| 133 |
|
| 134 |
* Decoupled computing the activation degree and triggering the rule. Previously, the activation degree of a rule was computed and triggered at the same time using `Rule::activate(TNorm* conjunction, SNorm* disjunction, TNorm* implication)`. Currently, there are two methods: `fl::scalar activateWith(TNorm* conjunction, SNorm* disjunction)`, which computes, stores and returns the activation degree of the rule; and `trigger(TNorm* implication)`, which, if the rule is enabled and the activation degree is greater than zero, then the rule is triggered to modify the consequent. |
| 135 |
|
| 136 |
* Renamed `RuleBlock::activation` operator to `RuleBlock::implication` operator, and so its respective getters and setters. |
| 137 |
* Added `RuleBlock::activation` method and respective getters and setters. |
| 138 |
* In `RuleBlock::activate()`, if there is no activation method, the `General` activation method is automatically set in order to have backward compatibility. |
| 139 |
|
| 140 |
* 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`. |
| 141 |
|
| 142 |
* Added identifier `FL_IFINAL` to classes `Proposition` and `Operator`. |
| 143 |
|
| 144 |
Term |
| 145 |
---- |
| 146 |
* Performance improvements. |
| 147 |
* `Discrete` term uses binary search instead of linear search, hence significantly improving performance. |
| 148 |
* `Discrete` term can create a `Discrete` term from any other term. |
| 149 |
* New `Binary` edge term. |
| 150 |
* Added method `bool Term::isMonotonic()` to determine whether the term is monotonic (returns true only for `Concave`, `Ramp`, `Sigmoid`, `SShape`, and `ZShape`). |
| 151 |
* Refactored static method `WeightedDefuzzifier::tsukamoto()` into non-static method `Term::tsukamoto()`, which is overriden by each of the terms that can be used for `tsukamoto` controllers. |
| 152 |
* Privatized `Term::name` and the properties of each subclass of `Term`. |
| 153 |
* Inlined generic methods in `[Linear|Discrete].h` |
| 154 |
* Renamed `Activated::activation` operator to `Activated::implication` and its respective getters and setters. |
| 155 |
* Renamed `Accumulated` term to `Aggregated` term, and its `accumulation` operator to `aggregation` operator including getters and setters. |
| 156 |
* For performance improvements, terms of `Aggregated` term are copies of objects in stack memory rather than pointers to objects in heap memory. |
| 157 |
* Refactored static `Term::updateReference()` to non-static being overrided by `Linear`, `Function`. |
| 158 |
* Added enum `[Ramp|Sigmoid]::Direction` to specify the direction of the term. |
| 159 |
* Added `Term::clone()` method to create a copy of any term. |
| 160 |
|
| 161 |
* 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. |
| 162 |
* Fixed bug in `Function` when enclosing variable in double parenthesis. |
| 163 |
|
| 164 |
|
| 165 |
|
| 166 |
Variable |
| 167 |
-------- |
| 168 |
* Refactored `[Input|Output]Variable::[get|set][Input|Output]Value()` to a single value in `Variable::[get|set]Value()`. |
| 169 |
* Refactored `OutputVariable::[is|set]LockedOutputValueInRange()` to its parent `Variable::[is|set]LockValueInRange()`. |
| 170 |
* Added option to lock value in range to input variables by refactoring `OutputVariable::lockValueInRange` to `Variable::lockValueInRange`. |
| 171 |
* Renamed `OutputVariable::[is|set]LockedPreviousValue()` to `OutputVariable::[is|set]LockPreviousValue()`. |
| 172 |
* Added wrapping method `OutputVariable::[get|set]Aggregation()`. |
| 173 |
* For performance improvements, added enum `Variable::Type` and methods `Variable::type()` to indicate whether the variable is of `Type::InputVariable` or `Type::OutputVariable`. Thus, it is no longer necessary to `dynamic_cast` variables to find out whether they are input or output variables. |
| 174 |
|
| 175 |
|
| 176 |
|
| 177 |
Benchmark |
| 178 |
--------- |
| 179 |
* Benchmark the time it takes your engine to perform a given number of evaluations (available only when building using C++11) over a given number of independent runs. |
| 180 |
* Measure the accuracy of the engine using the mean squared error between the obtained values and the expected values. |
| 181 |
* Export the benchmark results to text. |
| 182 |
|
| 183 |
Complexity |
| 184 |
---------- |
| 185 |
* New complexity methods in the components involved in the operation of an engine. |
| 186 |
* Complexity methods are completely decoupled from the operation of an engine, so they do not affect the performance of the engines. |
| 187 |
|
| 188 |
Console |
| 189 |
------- |
| 190 |
* Benchmark engines from the FuzzyLite Console |
| 191 |
* Hybrid example in Console |
| 192 |
|
| 193 |
Engine |
| 194 |
------ |
| 195 |
* Description string for Engine |
| 196 |
* Changed signature of `::configure(TNorm* conjunction, SNorm* disjunction, TNorm* activation, SNorm* accumulation, int resolution)` to `::configure(TNorm* conjunction, SNorm* SNorm* disjunction, TNorm* implication, SNorm* aggregation, Activation* activation)`, where `implication` and `aggregation` are better names for activation and accumulation (respectively), and the `activation` refers to an activation method (see Activation Methods) |
| 197 |
|
| 198 |
Exception.h |
| 199 |
----------- |
| 200 |
* Definition FL_BACKTRACE_OFF in Exception.cpp renamed to FL_BACKTRACE, hence functionality is changed. |
| 201 |
|
| 202 |
fuzzylite.h |
| 203 |
----------- |
| 204 |
* Removed definitions FL_VERSION, FL_DATE from fuzzylite.h |
| 205 |
* Renamed fuzzylite::debug() to fuzzylite::isDebugging() |
| 206 |
* Renamed fuzzylite::logging() to fuzzylite::isLogging() |
| 207 |
* Inlined methods of fuzzylite.h |
| 208 |
* Removed definition `FL_CPP11` and replaced it for `FL_CPP98`. By default, `FL_CPP98` is not defined, hence building using `C++11`. |
| 209 |
|
| 210 |
|
| 211 |
Examples |
| 212 |
-------- |
| 213 |
* New example of hybrid engines. |
| 214 |
* New example on obstacle avoidance for Mamdani, Takagi-Sugeno, and Hybrid engines. |
| 215 |
* New R scripts for each example and its respective surfaces in `pdf` formats. |
| 216 |
* Updated examples to use the new properties `InputVariable::lock-range`, `Engine::description`, `[Input|Output]Variable::description`, `RuleBlock::description`, `RuleBlock::implication`, `RuleBlock::activation`, and `OutputVariable::aggregation`. |
| 217 |
* Updated C++ and Java examples to reflect variable names instead of generic names. |
| 218 |
|
| 219 |
|
| 220 |
|