public BDD varRange(BigInteger lo, BigInteger hi) {
if (lo.signum() < 0 || hi.compareTo(size()) >= 0 || lo.compareTo(hi) > 0) {
throw new BDDException("range <" + lo + ", " + hi + "> is invalid");
}
BDDFactory factory = getFactory();
BDD result = factory.zero();
int[] ivar = this.vars();
while (lo.compareTo(hi) <= 0) {
BDD v = factory.universe();
for (int n = ivar.length - 1; ; n--) {
if (lo.testBit(n)) {
v.andWith(factory.ithVar(ivar[n]));
} else {
v.andWith(factory.nithVar(ivar[n]));
}
BigInteger mask = BigInteger.ONE.shiftLeft(n).subtract(BigInteger.ONE);
if (!lo.testBit(n) && lo.or(mask).compareTo(hi) <= 0) {
lo = lo.or(mask).add(BigInteger.ONE);
break;
}
}
result.orWith(v);
}
return result;
}
public static void main(String[] args) {
BDDFactory bdd = init(1000000, 100000);
System.out.println("One: " + CUDDFactory.one);
System.out.println("Zero: " + CUDDFactory.zero);
BDDDomain[] doms = bdd.extDomain(new int[] {50, 10, 15, 20, 15});
BDD b = bdd.one();
for (int i = 0; i < doms.length - 1; ++i) {
b.andWith(doms[i].ithVar(i));
}
for (int i = 0; i < bdd.numberOfDomains(); ++i) {
BDDDomain d = bdd.getDomain(i);
int[] ivar = d.vars();
System.out.print("Domain #" + i + ":");
for (int j = 0; j < ivar.length; ++j) {
System.out.print(' ');
System.out.print(j);
System.out.print(':');
System.out.print(ivar[j]);
}
System.out.println();
}
BDDPairing p = bdd.makePair(doms[2], doms[doms.length - 1]);
System.out.println("Pairing: " + p);
System.out.println("Before replace(): " + b);
BDD c = b.replace(p);
System.out.println("After replace(): " + c);
c.printDot();
}
public BDD ithVar(BigInteger val) {
if (val.signum() < 0 || val.compareTo(size()) >= 0) {
throw new BDDException(val + " is out of range");
}
BDDFactory factory = getFactory();
BDD v = factory.universe();
int[] ivar = this.vars();
for (int n = 0; n < ivar.length; n++) {
if (val.testBit(0)) v.andWith(factory.ithVar(ivar[n]));
else v.andWith(factory.nithVar(ivar[n]));
val = val.shiftRight(1);
}
return v;
}
/**
* Builds a BDD which is true for all the possible assignments to the variable blocks that makes
* the blocks equal.
*
* <p>Compare to fdd_equals/fdd_equ.
*
* @param that
* @return BDD
*/
public BDD buildEquals(BDDDomain that) {
if (!this.size().equals(that.size())) {
throw new BDDException(
"Size of "
+ this
+ " != size of that "
+ that
+ "( "
+ this.size()
+ " vs "
+ that.size()
+ ")");
}
BDDFactory factory = getFactory();
BDD e = factory.universe();
int[] this_ivar = this.vars();
int[] that_ivar = that.vars();
for (int n = 0; n < this.varNum(); n++) {
BDD a = factory.ithVar(this_ivar[n]);
BDD b = factory.ithVar(that_ivar[n]);
a.biimpWith(b);
e.andWith(a);
}
return e;
}
/**
* Returns what corresponds to a disjunction of all possible values of this domain. This is more
* efficient than doing ithVar(0) OR ithVar(1) ... explicitly for all values in the domain.
*
* <p>Compare to fdd_domain.
*/
public BDD domain() {
BDDFactory factory = getFactory();
/* Encode V<=X-1. V is the variables in 'var' and X is the domain size */
BigInteger val = size().subtract(BigInteger.ONE);
BDD d = factory.universe();
int[] ivar = vars();
for (int n = 0; n < this.varNum(); n++) {
if (val.testBit(0)) d.orWith(factory.nithVar(ivar[n]));
else d.andWith(factory.nithVar(ivar[n]));
val = val.shiftRight(1);
}
return d;
}
public BDD buildAdd(BDDDomain that, int bits, long value) {
if (bits > this.varNum() || bits > that.varNum())
throw new BDDException(
"Number of bits requested ("
+ bits
+ ") is larger than domain sizes "
+ this.varNum()
+ ","
+ that.varNum());
BDDFactory bdd = getFactory();
if (value == 0L) {
BDD result = bdd.universe();
int n;
for (n = 0; n < bits; n++) {
BDD b = bdd.ithVar(this.ivar[n]);
b.biimpWith(bdd.ithVar(that.ivar[n]));
result.andWith(b);
}
for (; n < Math.max(this.varNum(), that.varNum()); n++) {
BDD b = (n < this.varNum()) ? bdd.nithVar(this.ivar[n]) : bdd.one();
b.andWith((n < that.varNum()) ? bdd.nithVar(that.ivar[n]) : bdd.one());
result.andWith(b);
}
return result;
}
int[] vars = new int[bits];
System.arraycopy(this.ivar, 0, vars, 0, vars.length);
BDDBitVector y = bdd.buildVector(vars);
BDDBitVector v = bdd.constantVector(bits, value);
BDDBitVector z = y.add(v);
int[] thatvars = new int[bits];
System.arraycopy(that.ivar, 0, thatvars, 0, thatvars.length);
BDDBitVector x = bdd.buildVector(thatvars);
BDD result = bdd.one();
int n;
for (n = 0; n < x.size(); n++) {
BDD b = x.bitvec[n].biimp(z.bitvec[n]);
result.andWith(b);
}
for (; n < Math.max(this.varNum(), that.varNum()); n++) {
BDD b = (n < this.varNum()) ? bdd.nithVar(this.ivar[n]) : bdd.one();
b.andWith((n < that.varNum()) ? bdd.nithVar(that.ivar[n]) : bdd.one());
result.andWith(b);
}
x.free();
y.free();
z.free();
v.free();
return result;
}
