Exemple #1
0
 scalar Accumulated::activationDegree(const Term* forTerm) const {
     scalar result = 0.0;
     for (std::size_t i = 0; i < _terms.size(); ++i) {
         Activated* activatedTerm = _terms.at(i);
         if (activatedTerm->getTerm() == forTerm) {
             if (_accumulation.get()) result = _accumulation->compute(result, activatedTerm->getDegree());
             else result += activatedTerm->getDegree(); //Default for WeightDefuzzifier
         }
     }
     return result;
 }
Exemple #2
0
    scalar WeightedAverage::defuzzify(const Term* term,
            scalar minimum, scalar maximum) const {
        const Accumulated* fuzzyOutput = dynamic_cast<const Accumulated*> (term);
        if (not fuzzyOutput) {
            std::ostringstream ss;
            ss << "[defuzzification error]"
                    << "expected an Accumulated term instead of"
                    << "<" << term->toString() << ">";
            throw fl::Exception(ss.str(), FL_AT);
        }

        minimum = fuzzyOutput->getMinimum();
        maximum = fuzzyOutput->getMaximum();

        scalar sum = 0.0;
        scalar weights = 0.0;

        if (not fuzzyOutput->getAccumulation()) {
            Type type = _type;
            for (int i = 0; i < fuzzyOutput->numberOfTerms(); ++i) {
                Activated* activated = fuzzyOutput->getTerm(i);
                scalar w = activated->getDegree();

                if (type == Automatic) type = inferType(activated->getTerm());

                scalar z = (type == TakagiSugeno)
                        //? activated.getTerm()->membership(fl::nan) Would ensure no Tsukamoto applies, but Inverse Tsukamoto with Functions would not work.
                        ? activated->getTerm()->membership(w) //Provides Takagi-Sugeno and Inverse Tsukamoto of Functions
                        : tsukamoto(activated->getTerm(), w, minimum, maximum);

                sum += w * z;
                weights += w;
            }
        } else {
            typedef std::map<const Term*, std::vector<Activated*> > TermGroup;
            TermGroup groups;
            for (int i = 0; i < fuzzyOutput->numberOfTerms(); ++i) {
                Activated* value = fuzzyOutput->getTerm(i);
                const Term* key = value->getTerm();
                groups[key].push_back(value);
            }
            TermGroup::const_iterator it = groups.begin();
            Type type = _type;
            while (it != groups.end()) {
                const Term* activatedTerm = it->first;
                scalar accumulatedDegree = 0.0;
                for (std::size_t i = 0; i < it->second.size(); ++i)
                    accumulatedDegree = fuzzyOutput->getAccumulation()->compute(
                        accumulatedDegree, it->second.at(i)->getDegree());

                if (type == Automatic) type = inferType(activatedTerm);

                scalar z = (type == TakagiSugeno)
                        //? activated.getTerm()->membership(fl::nan) Would ensure no Tsukamoto applies, but Inverse Tsukamoto with Functions would not work.
                        ? activatedTerm->membership(accumulatedDegree) //Provides Takagi-Sugeno and Inverse Tsukamoto of Functions
                        : tsukamoto(activatedTerm, accumulatedDegree, minimum, maximum);

                sum += accumulatedDegree * z;
                weights += accumulatedDegree;

                ++it;
            }
        }
        return sum / weights;
    }