diff options
Diffstat (limited to 'ChangeLog')
| -rw-r--r-- | ChangeLog | 231 |
1 files changed, 231 insertions, 0 deletions
diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..012623e --- /dev/null +++ b/ChangeLog @@ -0,0 +1,231 @@ +Version 5.1 +* Updated `JavaExporter` to remove boolean from exported `Function.create(String name, String formula, Engine engine, boolean)` +* Improved CMakeLists to remove errors from warnings, and exclude library rt for benchmarks +* Moved benchmarks in `Console.cpp` to FL_CPP11 in order to get rid of rt library +* Made most constructors `explicit` +* FL_WINDOWS, FL_APPLE and FL_UNIX are automatically defined in `fuzzylite.h` +* Option to prefix namespace `fl::` in class `CppExporter` +* New methods `FclExporter::toString([[Input|Output]Variable]|RuleBlock|Norm])` +* New methods `FclExporter::toString(Norm)` +* Identifier FL_IOVERRIDE in SNorm and TNorm +* New private methods `CloningFactory::register[Operators|Functions]` +* `FisExporter` merges all ruleblocks into one +* New `Rule::clone()` method +* Fixed `FclImporter` exception on malformed Term +* Made sure this version builds successfully with g++5.1 + + +Version 5.0 +* Modified Function::Unary and Binary to take scalar instead of double +* Fixed building using -DFL_USE_FLOAT=ON +* Added deductive type of Engine with Engine::type() +* Fixed minor memory leak at RuleBlock (conjunction, disjunction, activation) +* Fixed minor memory leak at Accumulated (accumulation, thresholded terms) +* Fixed minor memory leak at OutputVariable (defuzzifier) +* Fixed minor memory leak at Function::Node +* Fixed minor memory leak at FactoryManager +* Improved handling of Exceptions +* Modified FclExporter and FisExporter to provide backward compatibility with FCL and FIS formats +* Updated the FIS and FCL examples for backward compatibility +* Included the original example files +* Updated FLD examples produced from the engines of the original examples +* Fixed some original examples of takagi-sugeno to use AlgebraicProduct activation +* FldExporter no longer restarts the engine +* Fixed rethrowing of exceptions to provide proper information about errors! +* Catching std::exceptions where possible to avoid unexpected exceptions +* FldExporter exports from a custom input dataset +* Console includes option to read custom input dataset from file +* Console provides more information about its usage +* Renamed methods FldExporter::toWriter() to FldExporter::write() +* Removed variable and methods for property FldExporter::maximum +* Accuracy improvements importing fis files with large number of decimals +* Updated FLD examples to reflect accuracy +* Changed operation for multiple hedges to operate from last to first +* Fixed OutputVariable to store last valid output value regardless of locks +* Renamed Op::isNan to Op::isNaN +* New OutputVariable::(get|set)OutputValue to store value from defuzzification +* Changed OutputVariable::defuzzify to store its output value +* Changed return type of scalar OutputVariable::defuzzify to void OutputVariable::defuzzify +* Renamed OutputVariable::(get|set)LastValidOutput to OutputVariable::(get|set)LastValidOutputValue +* Removed OutputVariable::defuzzifyNoLocks +* Removed const from Term* Accumulated::(get|set)Accumulation +* Added InputVariable::fuzzyInputValue and OutputVariable::fuzzyOutputValue +* Removed defaults in Engine::configure +* Added Engine::configure without conjuntion and disjuntion +* Added parameter string to Engine::type +* Changed Engine::isReady +* Correct handling of integral defuzzification with min|max=NaN|Inf +* Added method Rule::isLoaded to determine whether a rule is to be activated +* Added method Rule::unload to allow existence of invalid rules +* Added methods Engine::set((Input|Output)Variables), Engine::setRuleBlocks +* Added method RuleBlock::setRules +* Changed visibility of Rule::setText to public +* Added method Rule::load(const Engine*) +* Renamed term Thresholded to Activated +* Renamed Thresholded::(set|get)Threshold to Activated::(set|get)Degree +* Removed variable Rule::FL_ASSIGNS="=" and method Rule::assignsKeyword() +* Modified original takagi-sugeno examples to reflect proper activation and accumulation +* Moved Engine::_hedges (and methods) to Rule::_hedges +* Renamed Antecedent::(get|set)Root to Antecedent::(get|set)Expression +* Added (Antecedent|Consequent)::(get|set)Text +* Added (Antecedent|Consequent)::load|unload +* Renamed typedef Factory::Creator to Factory::Constructor +* Added an M-file to compare output values of fuzzylite engines with Matlab +* Removed const from Norms in RuleBlock::(get|set)(Activation|Conjunction|Disjunction) +* Deleted method Op::repeat +* Added built-in functions gt,lt,ge,le,eq and operator ! +* Renamed Term::copy to Term::clone in every Term +* Added copy constructors and assignment operators to (Input|Output)Variable +* Added copy constructors and assignment operators to Accumulated +* Merged Function::Operator and Function::BuiltInFunction into Function::Element +* Created FunctionFactory for Function::Elements +* IMPORTANT: Changed starting precedence of Function::Element::Operators to 10 (refer to FunctionFactory) +* Setters of FactoryManager no longer delete previous factories +* Renamed Factory<T>::(register|deregister)Class to Factory<T>::(register|deregister)Constructor +* Renamed Factory<T> to ConstructionFactory<T> +* Created CloningFactory<T> +* Moved functions and operators of term Function to a FunctionFactory +* Added clone methods to Defuzzifiers, Hedges, Norms, and Terms +* Changed Exception::btCallStack(const int) to Exception::btCallStack(void) +* Using std::auto_ptr to (T|S)Norms in RuleBlock, SNorm in Accumulated, and Defuzzifier in OutputVariable +* Added methods Engine::set((Input|Output)Variable) and Engine::setRuleBlock() +* Added method RuleBlock::reloadRules() +* Changed Linear pointers to input variables for a pointer to Engine +* Added support to compare infinity values with fl::Op::isEq and therefore other comparison operators +* Parameters of all terms are set to fl::nan by default +* Added methods Engine::(input|output)Variables() and ::ruleBlocks() to return mutable references +* Added method Variable::terms() to return mutable reference +* Added method RuleBlock::rules() to return mutable reference +* Added methods Ramp::direction() and Sigmoid::direction() to represent direction of slope +* Added method fl::Op::isFinite(x) to check x is not (nan or inf) +* Changed fl::Op::isEq(a,b) to return true if a = b = NaN +* Added method Accumulated::terms() to return mutable reference +* Changed visibility of Linear::coefficients to protected +* Added methods Linear::coefficients(), Linear::setCoefficients() +* Removed public variables Discrete::x,y +* Added in Discrete a typedef to std::pair<scalar, scalar> Pair, and changed signatures of methods and types of their parameters +* Changed representation of Discrete::(x,y) from std::vector<scalar> to std::vector<Pair> +* Added methods Discrete::setXY(), Discrete::xy(), ::xy(int) to set and get new representation +* Added methods Discrete::toPairs(std::vector<scalar>) and Discrete::toVector(std::vector<Pair>) +* Added method Discrete::formatXY() to get pairs (x,y) nicely formatted +* Linear term no longer throws exception when inputVariables != |coefficients| +* Changed visibility of Function::root to protected and renamed it to Function::_root +* Added method Function::root() to return pointer to Function::_root +* Added option to prefix the namespace in CppExporter, by default it does not prefix +* Added method OutputVariable::clear() to restart the output variable +* Renamed variable OutputVariable::_lastValidOutputValue to ::_previousOutputValue +* Renamed method OutputVariable::(get|set)LastValidOutputValue to ::(get|set)PreviousOutputValue +* Renamed variable OutputVariable::_lockOutputRange to ::_lockOutputValueInRange +* Renamed method OutputVariable::setLockOutputRange() to ::setLockOutputValueInRange +* Renamed method OutputVariable::isLockingOutputRange() to ::isLockedOutputValueInRange +* Renamed variable OutputVariable::_lockValidOutput to ::_lockPreviousOutputValue +* Renamed method OutputVariable::setLockValidOutput() to ::setLockPreviousOutputValue +* Renamed method OutputVariable::isLockingValidOutput() to ::isLockedPreviousOutputValue +* Renamed FLL property 'lock-valid' to 'lock-previous' +* Renamed FIS property 'LockValid' to 'LockPrevious' +* Renamed FCL property 'LOCK: VALID' to 'LOCK: PREVIOUS' +* Added method Engine::variables() to retrieve both Input and OutputVariables +* Added method Term::updateReference(Term*, Engine*) to ensure Linear and Function terms to update references of engines +* Added method Engine::updateReferences() to update references to the engine in its terms. +* Added in Discrete a typedef to std::pair<scalar, scalar> Pair, and changed signatures of methods and types of their parameters +* Added terms: Concave, Cosine and Spike +* 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)) +* Removed method fuzzylite::configuration() +* Renamed MACRO FL_DEBUG to FL_DBG +* Renamed MACRO (FL_BEGIN_DEBUG_BLOCK and FL_END_DEBUG_BLOCK) to (FL_DEBUG_BEGIN and FL_DEBUG_END) +* Renamed methods in (Fis|Fcl)Importers::extract? to ::parse? +* Made defaultResolution a static property of IntegralDefuzzifiers +* Added method Engine::type(name, reason) to show type and reason why type +* Added method Engine::clone() +* Added support for Tsukamoto with Concave terms +* Changed Accumulated to take Activated* terms instead of const Terms* +* Deleted class Tsukamoto +* Created class WeightedDefuzzifier from which Weighted(Average|Sum) derive with options: Automatic|TakagiSugeno|Tsukamoto +* Added methods WeightedDefuzzifier::tsukamoto() and ::inferType() +* Added benchmarks for fuzzylite in Linux +* Created the FuzzyLite Interactive Console +* Added basic rule chaining such that Output Variables can be utilized as antecedents +* Added two examples for rule chaining: mamdani/Laundry.fll and mamdani/SimpleDimmerInverse.fll +* Added Term::(get|set)Height and changed all terms accordingly +* Renamed method Op::makeValidId to Op::validName, which now returns "unnamed" for empty strings. +* Converted examples/original/*.fis to examples/original/*.fll +* Removed Exception Specification from methods in Discrete, Linear and Function terms +* Changed name of debug libraries to fuzzylited.dll and fuzzylite-staticd.lib +* Removed method Operation::toScalar(std::string, bool, scalar) +* Added method Operation::toScalar(std::string) [throws Exception], and ::toScalar(std::string, scalar alternative) throw() +* Added method ImEx::(from|to)File to import and export engines using files +* WeightedAverage and WeightedSum without Activation operators have default behaviour, i.e., AlgebraicProduct +* FactoryManager utilizes smart pointers. +* Rule utilizes smart pointers for Antecedent and Consequent +* Exceptions are thrown when Conjunction, Disjunction, Activation and Accumulation operators are NULL when they are required +* Exception is thrown when Defuzzifier is required and not set. +* Added support for C++11 utilizing smart pointers, identifiers (override, noexcept), and delete identifiers to DISABLE_COPY(Class) +* Macros for identifiers are FL_IOVERRIDE, FL_IFINAL, FL_IDEFAULT, FL_IDELETE, and FL_INOEXCEPT (fl/fuzzylite.h) +* 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. +* Added constant fl::null to refer to 0L (C++98) or nullptr (C++11) +* Added macros FL_DEFAULT_COPY(Class), FL_DEFAULT_MOVE(Class), and FL_DEFAULT_COPY_AND_MOVE(Class) for default copy and move constructors and operators +* Added build.sh to build fuzzylite +* Changed default to fuzzylite::_macheps = 1e-6; +* Renamed macro FL_EXPORTS to FL_API +* Added macro FL_SHARED_LIBRARY and FL_STATIC_LIBRARY to be defined when building shared and static libraries + + +Version 4.0 +* FuzzyRule merged with Rule, and FuzzyRule deleted. +* FuzzyAntecedent merged with Antecedent, and FuzzyAntecedent deleted +* FuzzyConsequent merged with Consequent, and FuzzyConsequent deleted +* FuzzyExpression renamed Expression +* Renamed Rule::get/setUnparsedRule to get/setText +* Renamed RuleBlock::get/set(Tnorm|Snorm) to get/set(Conjunction|Disjunction) +* Renamed RuleBlock::fireRules to activate +* Renamed Rule::fireStrength to activationDegree, fire to activate +* Renamed Consequent::fire to modify +* Created IntegralDefuzzifier to extract divisions from Defuzzifier +* Renamed divisions from IntegralDefuzzifier to resolution, FL_DIVISIONS to FL_RESOLUTION +* Deleted MaximumDefuzzifier +* Centroid, Bisector, and Largest/Smallest/Mean Defuzzifiers inherit from IntegralDefuzzifier +* Changed names of arithmetic operations in fl::Operation +* Renamed Function::get/set(Infix) to get/set(Formula) +* Renamed InputVariable::get/set(Input) to get/set(InputValue) +* Renamed Antecedent::firingStrength to activationDegree +* Renamed Antecedent::toString/(Prefix,Infix,Postfix) to to/(Prefix,Infix,Postfix) +* Renamed Rule::FL_ASSIGN to Rule::FL_EQUALS +* New method restart in Engine +* New methods Engine::setInputValue(name, value), scalar Engine::getOutputValue(name) +* Renamed Op::str(vector/varargs) to Op::join(vector/varargs) +* Refactored associtativity, unary and binary properties in Element within Function +* Removed unnecessary Hedges creation upon importing engines, now is automatic via Factories +* Created the JavaExporter +* Renamed methods within Fis/Fcl/CppExporter to toString(*); +* Extracted TNorms and SNorms from TNorm.h/cpp and SNorm.h/cpp +* Created proper Factories with registration of classes and constructors +* Renamed method Factory::create to Factory::createInstance +* Added static constructor method to every Defuzzifier, Hedge, TNorm, and SNorm +* Removed FL_PRECISION, FL_DECIMALS as Macros, and created static variables in fuzzylite.h +* Renamed FL_PRECISION to macheps, i.e., machine epsilon to differentiate real numbers +* Removed FL_DEBUG and created a static variable in fuzzylite.h +* Removed FL_NO_LOG as it is now controlled with fuzzylite::logging(), previously named logEnabled() +* Libraries and Console application are both built in folder bin/ (previously libraries were at lib/) +* Removed Engine::toStringFis/Fcl/Cpp to encourage use of Fcl/Fis/CppExporters instead +* Renamed Op::logical_and to Op::logicalAnd, Op::logical_or to Op::logicalOr +* Added support to Fis/FclImporters to treat comments (%,#,//,/*) in fis and fcl files +* Created the Console application instead of previous demo +* Added Variable::range() to return (maximum - minimum) +* Removed Variable::isEmpty, use Variable::terms().empty() +* Removed RuleBlock::isEmpty, use RuleBlock::rules().empty() +* Created method Op::makeValidId to ensure names are valid +* Engine, Variable and Term::toString return FllExport::toString +* Created Term::parameters to return list of parameter values as string separated by spaces +* Created Term::configure to configure from Term::parameters +* FclImEx import and export terms using Term::parameters +* Created the FuzzyLite Language in FllImporter and FllExporter +* Created the FuzzyLite Dataset FldExporter +* Added property Enable to Engine, Variable and RuleBlock +* Extended FCL and FIS to consider Enabled properties +* Changed Engine::defuzzify() to consider enabled variables +* Changed Engine::process() to consider enabled rule blocks +* Changed OutputVariable::output() to OutputVariable::fuzzyOutput() +* Renamed Rectangle::minimum/maximum to Rectangle::start/end +* Renamed fuzzylite::shortVersion to fuzzylite::version +* Improved accuracy of Triangle and Trapezoid |