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::(register|deregister)Class to Factory::(register|deregister)Constructor * Renamed Factory to ConstructionFactory * Created CloningFactory * 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 Pair, and changed signatures of methods and types of their parameters * Changed representation of Discrete::(x,y) from std::vector to std::vector * Added methods Discrete::setXY(), Discrete::xy(), ::xy(int) to set and get new representation * Added methods Discrete::toPairs(std::vector) and Discrete::toVector(std::vector) * 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 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