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;
}
