int LinguisticVariable::positionFor(const LinguisticTerm* lterm) { for (int i = 0; i < numberOfTerms(); ++i) { if (FuzzyOperation::IsLEq(lterm->minimum(), term(i)->minimum())) { if (FuzzyOperation::IsEq(lterm->minimum(), term(i)->minimum())) { return lterm->membership(lterm->minimum()) > term(i)->membership(lterm->minimum()) ? i : i + 1; } return i; } } return numberOfTerms(); }
CompoundTerm LinguisticVariable::compound() const { CompoundTerm result("Accumulated " + name(), minimum(), maximum()); for (int i = 0; i < numberOfTerms(); ++i) { result.addTerm(*term(i)); } return result; }
CompoundTerm* CompoundTerm::clone() const { CompoundTerm* result = new CompoundTerm; for (int i = 0 ; i < numberOfTerms(); ++i){ result->addTerm(term(i)); } return result; }
void Polynomial::variablesIn(VariableSet & result) const { const int len = numberOfTerms(); // Bypass the reordering of the polynomial PolynomialIterator j = _terms.begin(); for(int i=1;i<=len&&!result.full();++i,++j) { (*j).MonomialPart().variablesIn(result); } };
int LinguisticVariable::indexOf(const std::string& name) const { for (int i = 0; i < numberOfTerms(); ++i) { if (term(i)->name() == name) { return i; } } return -1; }
std::string LinguisticVariable::toString() const { std::string result(name()); result += "={ "; for (int i = 0; i < numberOfTerms(); ++i) { result += term(i)->name() + " "; } result += "}"; return result; }
inline bool Polynomial::one() const { bool result = numberOfTerms() == 1; if(result) { // Bypass the checking on ordering PolynomialIterator j = _terms.begin(); result = (*j).MonomialPart().numberOfFactors()==0 && (*j).CoefficientPart().one(); } return result; };
void Polynomial::recomputeTotalDegree() { _totalDegree = 0; int temp; // The following code bypasses possible reordering. PolynomialIterator w = ((const GBList<Term> &)_terms).begin(); int sz = numberOfTerms(); for(int i=1;i<=sz;++i,++w) { temp = (*w).MonomialPart().numberOfFactors(); if(temp>_totalDegree) _totalDegree = temp; } };
LinguisticTerm* LinguisticVariable::bestFuzzyApproximation(flScalar crisp) { LinguisticTerm* result = NULL; flScalar highest_degree = -1.0; for (int i = 0; i < numberOfTerms(); ++i) { flScalar degree = term(i)->membership(crisp); if (degree > highest_degree) { result = term(i); highest_degree = degree; } } return result; }
std::string LinguisticVariable::fuzzify(flScalar crisp) const { std::vector<std::string> fuzzyness; for (int i = 0; i < numberOfTerms(); ++i) { flScalar degree = term(i)->membership(crisp); fuzzyness.push_back(StrOp::ScalarToString(degree) + "/" + term(i)->name()); } // StringOperator::sort(fuzzyness, false); std::string result; for (size_t i = 0; i < fuzzyness.size(); ++i) { result += fuzzyness[i] + (i < fuzzyness.size() - 1 ? " + " : ""); } return result; }
void Polynomial::addNewLastTerm(const Term & t) { PolynomialIterator w(begin()); const int sz = numberOfTerms(); if(sz>0) { for(int i=1;i<sz;++i,++w) {}; const Monomial & m = (*w).MonomialPart(); if(AdmissibleOrder::s_getCurrent().monomialGreater(t.MonomialPart(),m)) { errorc(__LINE__); }; if(t.MonomialPart()==m) { errorc(__LINE__); }; }; addTermToEnd(t); };
int Polynomial::totalDegree() const { int save = _totalDegree; _totalDegree = 0; int temp; PolynomialIterator w = _terms.begin(); int sz = numberOfTerms(); for(int i=1;i<=sz;++i,++w) { temp = (*w).MonomialPart().numberOfFactors(); if(temp>_totalDegree) _totalDegree = temp; } if(save!= _totalDegree) { WARNStream << "MXS:FIX:Polynomial::_totalDegree " << "save: " << save << " actual: " << _totalDegree << '\n'; } return _totalDegree; };
bool Polynomial::operator==(const Polynomial & x) const { bool result = true; if(this!=&x) { const int num = numberOfTerms(); if(num!=x.numberOfTerms()) { result = false; } else { PolynomialIterator j = begin(); PolynomialIterator k = x.begin(); for (int i=1;i<=num;++i,++j,++k) { if((*j)!=(*k)) { result = false; break; }; }; }; }; return result; };
void Polynomial::addNewLastTerm(const Term & t) { const int sz = numberOfTerms(); PolynomialIterator w(begin()); if(sz>0) { for(int i=1;i<sz;++i,++w) {}; const Monomial & m = (*w).MonomialPart(); if(AdmissibleOrder::s_getCurrent().monomialGreater(t.MonomialPart(),m)) { DBG(); }; if(t.MonomialPart()==m) { DBG(); }; }; Copy<Term> temp(t); addTermToEnd(temp); #ifdef POLYNOMIAL_USE_LIST putAllInList(); #endif };
void Polynomial::printNegative(MyOstream & os) { PolynomialIterator i = begin(); const int len = numberOfTerms(); if(len==0) { os << '0'; } else { OuTerm::NicePrint(os,-*i); ++i; for(int k=2;k<=len;++k,++i) { const Term & t = *i; if(t.CoefficientPart().sgn()<=0) { os << " + "; OuTerm::NicePrint(os,- t); } else { os << " - "; OuTerm::NicePrint(os,-t); } } } };
inline void Polynomial::check(int index) const { if(index<=0) error1(index); int num = numberOfTerms(); if(index > num) error2(index); };
flScalar LinguisticVariable::maximum() const { return numberOfTerms() == 0 ? sqrt(-1.0) : lastTerm()->maximum(); }
LinguisticVariable::~LinguisticVariable() { for (int i = numberOfTerms() - 1; i >= 0; --i) { delete removeTerm(i); } }
const Term & lastTerm() const { PolynomialIterator w(begin()); const int sz = numberOfTerms(); for(int i=1;i<sz;++i,++w) {}; return *w; };
void Polynomial::operator -= (const Term & aTERM) { reOrderPolynomial(); if(!aTERM.CoefficientPart().zero()) { const int num = numberOfTerms(); if(num==0) { addTermToEnd(-aTERM); } else { PolynomialIterator iter = begin(); bool shouldLoop = true; int cmp=-999; // a bogus value to get around compiler warning int place = 1; for (int i=1; i<=num && shouldLoop; ++i) { cmp = compareTwoMonomials(aTERM.MonomialPart(), (*iter).MonomialPart()); shouldLoop = cmp<0; if(shouldLoop) { ++place;++iter; } } // Either we are at the monomial or past it #if 0 // slow data integrity check for debugging if(!shouldLoop) { PolynomialIterator tempiter = _terms.begin(); tempiter.advance(place-1); if((*tempiter)!=(*iter)) errorc(__LINE__); }; #endif // If we are on the monomial if(cmp==0) { #ifdef DEBUG_POLY_ARITH if((*iter).MonomialPart()!=aTERM.MonomialPart()) errorc(__LINE__); #endif // Compute new coefficient Field newCoeff; newCoeff = (*iter).CoefficientPart() - aTERM.CoefficientPart(); // If new coefficient is zero, eliminate, else modify if(newCoeff.zero()) { _terms.removeElement(place); _numberOfTerms--; if(aTERM.MonomialPart().numberOfFactors()==_totalDegree) { recomputeTotalDegree(); } } else { InternalContainerType::iterator w = _terms.begin(); w.advance(place-1); #ifdef DEBUG_POLY_ARITH if((*w).MonomialPart()!=aTERM.MonomialPart()) { GBStream << "*w:" << *w << '\n'; GBStream << "aTERM:" << aTERM << '\n'; GBStream << "place:" << place << '\n'; GBStream << "*this:" << *this << '\n'; errorc(__LINE__); } #endif (*w).CoefficientPart(newCoeff); } } else if(place<=num) { // We are at a monomial higher with respect to compareTwoMonomials #ifdef CHECK_FOR_ZERO_COEFFICIENTS if(aTERM.CoefficientPart().zero()) errorc(__LINE__); #endif _terms.addElement(aTERM, place); _numberOfTerms++; if(_totalDegree<aTERM.MonomialPart().numberOfFactors()) { _totalDegree = aTERM.MonomialPart().numberOfFactors(); } } else // shouldLoop is True here { // The new term goes at the end of the list. addTermToEnd(aTERM); } } } #if 0 // slow data integrity check for debugging // A double check...REALLY SLOW const int finalsz = _numberOfTerms; PolynomialIterator iter = begin(); for(int ell=1;ell<=finalsz;++ell,++iter) { if((*iter).CoefficientPart().zero()) errorc(__LINE__); }; #endif };
inline bool Polynomial::zero() const { return numberOfTerms() == 0; };
LinguisticTerm* LinguisticVariable::lastTerm() const { return numberOfTerms() > 0 ? term(numberOfTerms() - 1) : NULL; }
void Polynomial::error2(int index) const { GBStream << "The " << index << "th term was requested.\n"; GBStream << "There are only " << numberOfTerms() << " terms.\n"; errorc(__LINE__); };
void Polynomial::operator -=(const Polynomial & p) { if(!p.zero()) { #if 0 if(zero()) { InternalContainerType::iterator w = _terms.begin(); const int sz = numberOfTerms(); for(int i=1;i<=sz;++i,++w) { (*w).Coefficient() = -1; } } else { #endif Polynomial temp(*this); setToZero(); const int sz1 = temp.numberOfTerms(); const int sz2 = p.numberOfTerms(); PolynomialIterator w1 = temp.begin(); PolynomialIterator w2 = p.begin(); int i1=1; int i2=1; #if 1 if(sz1>0) { #endif Term t1 = * w1; Term t2 = * w2; while(i1<=sz1 && i2<=sz2) { int cmp = compareTwoMonomials(t1.MonomialPart(),t2.MonomialPart()); //GBStream << "Subtract: cmp is " << cmp << '\n'; if(cmp==0) { t1.Coefficient() -= t2.CoefficientPart(); if(!t1.Coefficient().zero()) { //GBStream << "-=: Adding element" << TERM(c,t1.MonomialPart()) << '\n'; addTermToEnd(t1); } ++w1; ++i1; ++w2; ++i2; if(i1<=sz1 && i2<=sz2) { t1 = * w1; t2 = * w2; } } else if(cmp<0) { //GBStream << "-=Adding element" << t2 << '\n'; addTermToEnd(-t2); ++w2; ++i2; if(i2<=sz2) t2 = * w2; } else // if(cmp>0) { //GBStream << "-=Adding element" << t1 << '\n'; addTermToEnd(t1); ++w1; ++i1; if(i1<=sz1) t1 = * w1; } } #if 1 } #endif for(;i1<=sz1;++i1,++w1) { //GBStream << "-=Adding element" << *w1 << '\n'; addTermToEnd(*w1); } for(;i2<=sz2;++i2,++w2) { //GBStream << "-=Adding element" << -*w2 << '\n'; addTermToEnd(-(*w2)); } #if 0 } #endif } };
LinguisticTerm* LinguisticVariable::firstTerm() const { return numberOfTerms() > 0 ? term(0) : NULL; }
bool LinguisticVariable::isEmpty() const { return numberOfTerms() == 0; }