/**
* Convert the affine term to plain SMTLib term. Note that this is does not convert terms inside
* this term. Instead use the static method cleanup() for this, which works on arbitrary terms.
*
* @see SMTAffineTerm.cleanup
*/
private static Term toPlainTerm(Map<Term, Rational> summands, Rational constant, Sort sort) {
assert sort.isNumericSort();
Theory t = sort.getTheory();
int size = summands.size();
if (size == 0 || !constant.equals(Rational.ZERO)) size++;
Term[] sum = new Term[size];
int i = 0;
for (Map.Entry<Term, Rational> factor : summands.entrySet()) {
Term convTerm = factor.getKey();
if (!convTerm.getSort().equals(sort)) {
convTerm = t.term("to_real", convTerm);
}
if (factor.getValue().equals(Rational.MONE)) {
convTerm = t.term("-", convTerm);
} else if (!factor.getValue().equals(Rational.ONE)) {
Term convfac = t.rational(factor.getValue(), sort);
convTerm = t.term("*", convfac, convTerm);
}
sum[i++] = convTerm;
}
if (i < size) {
sum[i++] = t.rational(constant, sort);
}
return size == 1 ? sum[0] : t.term("+", sum);
}
/**
* Normalize this term. If this term corresponds to a singleton sum with coefficient 1 and
* constant 0, it will return the singleton term. Otherwise, it will return this.
*
* @param compiler TermCompiler used to unify SMTAffineTerms
* @return this or the singleton term corresponding to this.
*/
public Term normalize(TermCompiler compiler) {
if (mConstant.equals(Rational.ZERO) && mSummands.size() == 1) {
Map.Entry<Term, Rational> me = mSummands.entrySet().iterator().next();
if (me.getValue().equals(Rational.ONE)
// Fixes bug for to_real
&& me.getKey().getSort() == mSort) return me.getKey();
}
return compiler.unify(this);
}
/**
* Multiply a rational constant with this affine term.
*
* @param c the constant to multiply.
* @return the product of this and the constant.
*/
public SMTAffineTerm mul(Rational factor) {
if (factor.equals(Rational.ZERO)) return create(Rational.ZERO, mSort);
Rational constant = this.mConstant.mul(factor);
HashMap<Term, Rational> summands = new HashMap<Term, Rational>();
for (Map.Entry<Term, Rational> me : this.mSummands.entrySet()) {
summands.put(me.getKey(), me.getValue().mul(factor));
}
return create(summands, constant, mSort);
}
public static SMTAffineTerm create(Rational factor, Term subterm) {
Sort sort = subterm.getSort();
Map<Term, Rational> summands;
Rational constant;
if (factor.equals(Rational.ZERO)) {
summands = Collections.emptyMap();
constant = Rational.ZERO;
} else if (subterm instanceof SMTAffineTerm) {
SMTAffineTerm a = (SMTAffineTerm) subterm;
constant = a.mConstant.mul(factor);
summands = new HashMap<Term, Rational>();
for (Map.Entry<Term, Rational> me : a.mSummands.entrySet()) {
summands.put(me.getKey(), me.getValue().mul(factor));
}
} else if (subterm instanceof ConstantTerm) {
Object value = ((ConstantTerm) subterm).getValue();
if (value instanceof BigInteger) {
constant = Rational.valueOf((BigInteger) value, BigInteger.ONE).mul(factor);
summands = Collections.emptyMap();
} else if (value instanceof BigDecimal) {
BigDecimal decimal = (BigDecimal) value;
if (decimal.scale() <= 0) {
BigInteger num = decimal.toBigInteger();
constant = Rational.valueOf(num, BigInteger.ONE).mul(factor);
} else {
BigInteger num = decimal.unscaledValue();
BigInteger denom = BigInteger.TEN.pow(decimal.scale());
constant = Rational.valueOf(num, denom).mul(factor);
}
summands = Collections.emptyMap();
} else if (value instanceof Rational) {
constant = (Rational) value;
summands = Collections.emptyMap();
} else {
summands = Collections.singletonMap(subterm, factor);
constant = Rational.ZERO;
}
} else {
summands = Collections.singletonMap(subterm, factor);
constant = Rational.ZERO;
}
return create(summands, constant, sort);
}
public SMTAffineTerm addUnchecked(SMTAffineTerm a2, boolean sortCorrect) {
Map<Term, Rational> summands = new HashMap<Term, Rational>();
summands.putAll(this.mSummands);
for (Map.Entry<Term, Rational> entry : a2.mSummands.entrySet()) {
Term var = entry.getKey();
if (summands.containsKey(var)) {
Rational r = summands.get(var).add(entry.getValue());
if (r.equals(Rational.ZERO)) summands.remove(var);
else {
summands.put(var, r);
}
} else {
summands.put(var, entry.getValue());
}
}
return create(
summands,
mConstant.add(a2.mConstant),
sortCorrect ? mSort : a2.getSort().getName().equals("Real") ? a2.getSort() : mSort);
}
public boolean equals(Object o) { // NOCHECKSTYLE
if (!(o instanceof SMTAffineTerm)) return false;
SMTAffineTerm l = (SMTAffineTerm) o;
return mSort == l.mSort && mConstant.equals(l.mConstant) && mSummands.equals(l.mSummands);
}