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