OutputLVar* FuzzyEngine::outputLVar(const std::string& name) const { for (int i = 0; i < numberOfOutputLVars(); ++i) { if (outputLVar(i)->name() == name) { return outputLVar(i); } } return NULL; }
FL_INLINE flScalar FuzzyEngine::output(const std::string& output_lvar) const { OutputLVar* output = outputLVar(output_lvar); if (!output) { throw InvalidArgumentException(FL_AT, "Output variable <" + output_lvar + "> not registered in fuzzy engine"); } return output->output().defuzzify(); }
void FuzzyEngine::process(int ruleblock, bool clear) { if (clear) { for (int i = 0; i < numberOfOutputLVars(); ++i) { outputLVar(i)->output().clear(); } } ruleBlock(ruleblock)->fireRules(); }
std::string FuzzyEngine::fuzzyOutput(const std::string& output_lvar) const { flScalar defuzzified = output(output_lvar); OutputLVar* output = outputLVar(output_lvar); if (!output) { throw InvalidArgumentException(FL_AT, "Output variable <" + output_lvar + "> not registered in fuzzy engine"); } return output->fuzzify(defuzzified); }
int FuzzyEngine::indexOfOutputLVar(const std::string& name) const { for (int i = 0; i < numberOfOutputLVars(); ++i) { if (outputLVar(i)->name() == name) { return i; } } return -1; }
void MamdaniConsequent::execute(flScalar degree) { LinguisticTerm* rule_output = term()->clone(); flScalar modulation = degree * weight(); for (int i = 0; i < numberOfHedges(); ++i) { modulation = hedge(i)->hedge(modulation); } rule_output->setModulation(modulation); outputLVar()->output().addTerm(*rule_output); delete rule_output; }
std::string MamdaniConsequent::toString() const { std::stringstream ss; ss << outputLVar()->name() << " " << FuzzyRule::FR_IS; for (int i = 0; i < numberOfHedges(); ++i) { ss << " " << hedge(i)->name(); } ss << " " << term()->name(); if (weight() < flScalar(1.0)) { ss << " " + FuzzyRule::FR_WITH + " " << weight(); } return ss.str(); }
std::string FuzzyEngine::toString() const { std::stringstream ss; ss << "FUNCTION_BLOCK " << name() << "\n\n"; ss << "VAR_INPUT\n"; for (int i = 0; i < numberOfInputLVars(); ++i) { ss << inputLVar(i)->name() << ": REAL;\n"; } ss << "END_VAR\n\n"; for (int i = 0; i < numberOfInputLVars(); ++i) { ss << "FUZZIFY " << inputLVar(i)->name() << "\n"; for (int j = 0; j < inputLVar(i)->numberOfTerms(); ++j) { ss << inputLVar(i)->term(j)->toString() << ";\n"; } ss << "END_FUZZIFY\n\n"; } ss << "VAR_OUTPUT\n"; for (int i = 0; i < numberOfOutputLVars(); ++i) { ss << outputLVar(i)->name() << ": REAL\n"; } ss << "END_VAR\n\n"; for (int i = 0; i < numberOfOutputLVars(); ++i) { ss << "DEFUZZIFY " << outputLVar(i)->name() << "\n"; for (int j = 0; j < outputLVar(i)->numberOfTerms(); ++j) { ss << outputLVar(i)->term(j)->toString() << ";\n"; } ss << "END_DEFUZZIFY\n\n"; } for (int i = 0; i < numberOfRuleBlocks(); ++i) { ss << ruleBlock(i)->toString() << "\n\n"; } ss << "END_FUNCTION_BLOCK"; return ss.str(); }
void TakagiSugenoConsequent::execute(flScalar degree) { std::map<std::string, flScalar> variables; for (int i = 0; i < fuzzyEngine().numberOfInputLVars(); ++i) { variables[fuzzyEngine().inputLVar(i)->name()] = fuzzyEngine().inputLVar(i)->input(); } for (int i = 0; i < fuzzyEngine().numberOfOutputLVars(); ++i) { variables[fuzzyEngine().outputLVar(i)->name()] = fuzzyEngine().outputLVar(i)->output().defuzzify(); } TakagiSugenoTerm result(fuzzyEngine().fuzzyOperator(), postfixFunction()); result.setValue(_infix2postfix.evaluate(postfixFunction(), &variables)); result.setWeight(degree); outputLVar()->output().addTerm(result); }
OutputLVar* FuzzyEngine::removeOutputLVar(int index) { OutputLVar* result = outputLVar(index); _output_lvars.erase(_output_lvars.begin() + index); return result; }