Debian Codegraph @

CHANGELOG

raw
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