Uses of Class
net.sf.javabdd.BDD

Packages that use BDD
edu.wis.jtlv.env The main package of JTLV, most creational action are usually done through static procedures in object Env. 
edu.wis.jtlv.env.module All User interface to FDS and SMV modules. 
edu.wis.jtlv.env.spec Package dedicated to Specifications interface. 
edu.wis.jtlv.lib.old.games The main user library, with all published games algorithms which where implemented through JTLV. 
edu.wis.jtlv.lib.old.mc A library containing all implemented model checking algorithms. 
net.sf.javabdd   
 

Uses of BDD in edu.wis.jtlv.env
 

Methods in edu.wis.jtlv.env that return BDD
 BDD JTLVThread.adjustBDDToBase(BDD to_adjust)
           Copy the BDD from this manager to the base manager.
 BDD[] JTLVThread.adjustBDDToBase(BDD[] to_adjust)
           Copy an array of BDDs from this manager to the base manager.
 BDD JTLVThread.adjustBDDToManager(BDD to_adjust)
           Copy the BDD to the manager assigned to this thread.
 BDD[] JTLVThread.adjustBDDToManager(BDD[] to_adjust)
           Copy an array of BDDs to the manager assigned to this thread.
static BDD Env.allDeltaPred(BDD trans, BDD to)
           Given a set of state and a transitions, the procedure return all states which can lead in any number of steps to given states, excluding the given states themselves (in some cases this might be more efficient the allPred, and then conjuncting out the negation).
static BDD Env.allDeltaSucc(BDD from, BDD trans)
           Given a set of state and a transitions, the procedure return all states which can be reached in any number of steps from these states, excluding the given states themselves (in some cases this might be more efficient the allSucc, and then conjuncting out the negation).
static BDD Env.allPred(BDD trans, BDD to)
           Given a set of state and a transitions, the procedure return all states which can lead in any number of steps to given states.
static BDD Env.allSucc(BDD from, BDD trans)
           Given a set of state and a transitions, the procedure return all states which can be reached in a any number of steps from these states.
static BDD Env.copyBDDIntoBaseManager(BDD b)
           Copy a given BDD into the base BDD manager.
static BDD Env.copyBDDIntoManager(int idx, BDD b)
           Copy a given BDD into a given BDD manager.
static BDD Env.FALSE()
           The constant FALSE BDD.
static BDD Env.kDeltaPred(BDD trans, BDD to, int k)
           Given a set of state and a transitions, the procedure return all states which can lead in maximum k number of steps to given states, excluding the given states themselves (in some cases this might be more efficient the kPred, and then conjuncting out the negation).
static BDD Env.kDeltaSucc(BDD from, BDD trans, int k)
           Given a set of state and a transitions, the procedure return all states which can be reached in maximum k number of steps from these states, excluding the given states themselves (in some cases this might be more efficient the allSucc, and then conjuncting out the negation).
static BDD Env.kPred(BDD trans, BDD to, int k)
           Given a set of state and a transitions, the procedure return all states which can lead in maximum k number of steps to given states.
static BDD Env.kSucc(BDD from, BDD trans, int k)
           Given a set of state and a transitions, the procedure return all states which can be reached in maximum k number of steps from these states.
static BDD Env.loadBDD(java.lang.String filename)
           Load a BDD from the file system.
static BDD[] Env.multiCopyBDD(int[] managerIdxs, BDD toCopy)
           Do not call the standard copy procedure.
static BDD Env.pred(BDD trans, BDD to)
           Given a set of state and a transitions, the procedure return all states which can lead in a single step to the given states.
static BDD Env.prime(BDD unp_bdd)
           Given a BDD, returns the same BDD in its prime version of the variables.
static BDD Env.prime(BDD unp_bdd, ModuleBDDField[] couples)
           Given a BDD, returns the same BDD with the prime version of the given array of fields.
static BDD Env.succ(BDD from, BDD trans)
           Given a set of state and a transitions, the procedure return all states which can be reached in a single step from the given states.
static BDD Env.TRUE()
           The constant TRUE BDD.
static BDD Env.unprime(BDD p_bdd)
           Given a BDD, returns the same BDD in its unprime version of the fields.
static BDD Env.unprime(BDD p_bdd, ModuleBDDField[] couples)
           Given a BDD, returns the same BDD with the unprime version of the given array of fields.
 

Methods in edu.wis.jtlv.env with parameters of type BDD
 BDD JTLVThread.adjustBDDToBase(BDD to_adjust)
           Copy the BDD from this manager to the base manager.
 BDD[] JTLVThread.adjustBDDToBase(BDD[] to_adjust)
           Copy an array of BDDs from this manager to the base manager.
 BDD JTLVThread.adjustBDDToManager(BDD to_adjust)
           Copy the BDD to the manager assigned to this thread.
 BDD[] JTLVThread.adjustBDDToManager(BDD[] to_adjust)
           Copy an array of BDDs to the manager assigned to this thread.
static BDD Env.allDeltaPred(BDD trans, BDD to)
           Given a set of state and a transitions, the procedure return all states which can lead in any number of steps to given states, excluding the given states themselves (in some cases this might be more efficient the allPred, and then conjuncting out the negation).
static BDD Env.allDeltaSucc(BDD from, BDD trans)
           Given a set of state and a transitions, the procedure return all states which can be reached in any number of steps from these states, excluding the given states themselves (in some cases this might be more efficient the allSucc, and then conjuncting out the negation).
static BDD Env.allPred(BDD trans, BDD to)
           Given a set of state and a transitions, the procedure return all states which can lead in any number of steps to given states.
static BDD Env.allSucc(BDD from, BDD trans)
           Given a set of state and a transitions, the procedure return all states which can be reached in a any number of steps from these states.
static boolean Env.containPrimeVars(BDD set)
           Check whether the given BDD contains a prime version of some field.
static boolean Env.containUnprimeVars(BDD set)
           Check whether the given BDD contains an unprime version of some field.
static BDD Env.copyBDDIntoBaseManager(BDD b)
           Copy a given BDD into the base BDD manager.
static BDD Env.copyBDDIntoManager(int idx, BDD b)
           Copy a given BDD into a given BDD manager.
static BDD Env.kDeltaPred(BDD trans, BDD to, int k)
           Given a set of state and a transitions, the procedure return all states which can lead in maximum k number of steps to given states, excluding the given states themselves (in some cases this might be more efficient the kPred, and then conjuncting out the negation).
static BDD Env.kDeltaSucc(BDD from, BDD trans, int k)
           Given a set of state and a transitions, the procedure return all states which can be reached in maximum k number of steps from these states, excluding the given states themselves (in some cases this might be more efficient the allSucc, and then conjuncting out the negation).
static BDD Env.kPred(BDD trans, BDD to, int k)
           Given a set of state and a transitions, the procedure return all states which can lead in maximum k number of steps to given states.
static BDD Env.kSucc(BDD from, BDD trans, int k)
           Given a set of state and a transitions, the procedure return all states which can be reached in maximum k number of steps from these states.
static BDD[] Env.multiCopyBDD(int[] managerIdxs, BDD toCopy)
           Do not call the standard copy procedure.
static BDD Env.pred(BDD trans, BDD to)
           Given a set of state and a transitions, the procedure return all states which can lead in a single step to the given states.
static BDD Env.prime(BDD unp_bdd)
           Given a BDD, returns the same BDD in its prime version of the variables.
static BDD Env.prime(BDD unp_bdd, ModuleBDDField[] couples)
           Given a BDD, returns the same BDD with the prime version of the given array of fields.
static void Env.saveBDD(java.lang.String filename, BDD to_save)
           Save a BDD to the file system.
static BDD Env.succ(BDD from, BDD trans)
           Given a set of state and a transitions, the procedure return all states which can be reached in a single step from the given states.
static java.lang.String Env.toNiceSignleLineString(BDD b)
           Prepare a string representing the If-Then-Else form of the given BDD.
static java.lang.String Env.toNiceSignleLineString(Module con, BDD b)
           Prepare a string representing the If-Then-Else form of the given BDD.
static java.lang.String Env.toNiceString(BDD b)
           Prepare a string representing the If-Then-Else form of the given BDD.
static java.lang.String Env.toNiceString(BDD b, java.lang.String startIndent)
           Prepare a string representing the If-Then-Else form of the given BDD.
static java.lang.String Env.toNiceString(Module con, BDD b)
           Prepare a string representing the If-Then-Else form of the given BDD.
static java.lang.String Env.toNiceString(Module con, BDD b, java.lang.String startIndent)
           Prepare a string representing the If-Then-Else form of the given BDD.
static BDD Env.unprime(BDD p_bdd)
           Given a BDD, returns the same BDD in its unprime version of the fields.
static BDD Env.unprime(BDD p_bdd, ModuleBDDField[] couples)
           Given a BDD, returns the same BDD with the unprime version of the given array of fields.
 

Uses of BDD in edu.wis.jtlv.env.module
 

Methods in edu.wis.jtlv.env.module that return BDD
 BDD[] SMVModule.allJustice()
           
 BDD[] FDSModule.allJustice()
           
abstract  BDD[] ModuleWithWeakFairness.allJustice()
           
 BDD[] SMVModule.allPCompassion()
           
abstract  BDD[] ModuleWithStrongFairness.allPCompassion()
           
 BDD Module.allPred(BDD to)
           Given a set of state, this procedure return all states which can lead in any number of module steps to these states.
 BDD[] SMVModule.allQCompassion()
           
abstract  BDD[] ModuleWithStrongFairness.allQCompassion()
           
 BDD Module.allSucc(BDD from)
           This procedure return all states which the module can reach in any number of steps from given a set of state.
 BDD Module.controlStates(Module responder, BDD to)
           A state s is included in the returning result if the this module can force the responder to reach a state in "to".
 BDD Module.elimSuccChains(BDD scc)
           Eliminate states from scc which have no successors within scc.
 BDD ModuleBDDDefine.evalBDD()
           Evaluate the statement, and return the BDD value.
 BDD ModuleWithStrongFairness.feasible()
           This is essentially algorithm "FEASIBLE", from the article:
Yonit Ketsen, Amir Pnueli, Li-on Raviv, Elad Shahar, "Model checking with strong fairness".
 BDD Module.feasible()
           This is essentially algorithm "FEASIBLE", from the article:
Yonit Ketsen, Amir Pnueli, Li-on Raviv, Elad Shahar, "Model checking with strong fairness".
 BDD ModuleWithWeakFairness.feasible()
           This is essentially algorithm "FEASIBLE", from the article:
Yonit Ketsen, Amir Pnueli, Li-on Raviv, Elad Shahar, "Model checking with strong fairness".
 BDD ModuleWithStrongFairness.feasible2()
           Version which allows justice and compassion requirement to refer to the next state.
 BDD Module.feasible2()
           Version which allows justice and compassion requirement to refer to the next state.
 BDD ModuleWithWeakFairness.feasible2()
           Version which allows justice and compassion requirement to refer to the next state.
 BDD SMVModule.getValue(java.lang.String name)
           Get A BDD for the disjunct of all variables set to the given value.
 BDD Module.hasSuccessorsTo(BDD state, BDD to)
           
 BDD SMVModule.idleStep()
           
 BDD FDSModule.idleStep()
           
abstract  BDD Module.idleStep()
           Construct a BDD representing the idle transition of this module.
 BDD SMVModule.initial()
           
 BDD FDSModule.initial()
           
abstract  BDD Module.initial()
           Getter for the initial states in the module.
 BDD SMVModule.justiceAt(int i)
           
 BDD FDSModule.justiceAt(int i)
           
abstract  BDD ModuleWithWeakFairness.justiceAt(int i)
           Getter for a justice condition defined at the given index in the module.
 BDD SMVModule.pCompassionAt(int i)
           
abstract  BDD ModuleWithStrongFairness.pCompassionAt(int i)
           Getter for a P part of the compassion condition defined at the given index in the module.
 BDD[] SMVModule.popLastCompassion()
           
abstract  BDD[] ModuleWithStrongFairness.popLastCompassion()
           Removes the last compassion added to this module.
 BDD SMVModule.popLastJustice()
           
 BDD FDSModule.popLastJustice()
           
abstract  BDD ModuleWithWeakFairness.popLastJustice()
           Removes the last justice added to this module.
 BDD Module.pred(BDD to)
           Given a set of state, this procedure return all states which can lead in a single module step to these states.
 BDD SMVModule.presStep()
           
 BDD SMVModule.qCompassionAt(int i)
           
abstract  BDD ModuleWithStrongFairness.qCompassionAt(int i)
           Getter for a Q part of the compassion condition defined at the given index in the module.
 BDD Module.reachable()
           
 BDD[] Module.shortestPath(BDD source, BDD dest)
           Compute the shortest path from source to destination.
 BDD Module.succ(BDD from)
           This procedure return all states which the module can reach in a single step from given a set of state.
 BDD SMVModule.trans()
           
 BDD FDSModule.trans()
           
abstract  BDD Module.trans()
           Getter for the transition relation of the module.
 BDD Module.yieldStates(Module responder, BDD to)
           A state s in included in the returning result if responder module can force this module to reach a state in "to".
That is, regardless of how this module will move from the result, the responder module can choose an appropriate move into "to".
 

Methods in edu.wis.jtlv.env.module that return types with arguments of type BDD
 java.util.Vector<BDD> SMVModule.getAllConjunctTransElements()
           
 java.util.Vector<BDD> SMVModule.getAllIniRestrictions()
           
 java.util.Vector<BDD> FDSModule.getAllIniRestrictions()
           
abstract  java.util.Vector<BDD> Module.getAllIniRestrictions()
           
 java.util.Vector<BDD> SMVModule.getAllTransRestrictions()
           
 java.util.Vector<BDD> FDSModule.getAllTransRestrictions()
           
abstract  java.util.Vector<BDD> Module.getAllTransRestrictions()
           
 

Methods in edu.wis.jtlv.env.module with parameters of type BDD
 void SMVModule.addCompassion(BDD p, BDD q)
           
abstract  void ModuleWithStrongFairness.addCompassion(BDD p, BDD q)
           Add strong (compassion) winning condition to the module.
 void SMVModule.addInitial(BDD to_add)
           
 void FDSModule.addInitial(BDD to_add)
           
abstract  void Module.addInitial(BDD to_add)
           Conjunct the initial condition with the given condition.
 void SMVModule.addJustice(BDD to_add)
           
 void FDSModule.addJustice(BDD to_add)
           
abstract  void ModuleWithWeakFairness.addJustice(BDD to_add)
           Add weak (justice) winning condition to the module.
 BDD Module.allPred(BDD to)
           Given a set of state, this procedure return all states which can lead in any number of module steps to these states.
 BDD Module.allSucc(BDD from)
           This procedure return all states which the module can reach in any number of steps from given a set of state.
 void SMVModule.conjunctTrans(BDD to_add)
           
 void FDSModule.conjunctTrans(BDD to_add)
           
abstract  void Module.conjunctTrans(BDD to_add)
           Conjunct the transition relation with the given condition.
 BDD Module.controlStates(Module responder, BDD to)
           A state s is included in the returning result if the this module can force the responder to reach a state in "to".
 void SMVModule.disjunctTrans(BDD to_add)
           
 void FDSModule.disjunctTrans(BDD to_add)
           
abstract  void Module.disjunctTrans(BDD to_add)
           Disjunct the transition relation with the given condition.
 BDD Module.elimSuccChains(BDD scc)
           Eliminate states from scc which have no successors within scc.
 BDD Module.hasSuccessorsTo(BDD state, BDD to)
           
 BDD Module.pred(BDD to)
           Given a set of state, this procedure return all states which can lead in a single module step to these states.
 int SMVModule.restrictIni(BDD temp_ini)
           
 int FDSModule.restrictIni(BDD temp_ini)
           
abstract  int Module.restrictIni(BDD temp_ini)
           
 int SMVModule.restrictTrans(BDD temp_trans)
           
 int FDSModule.restrictTrans(BDD temp_trans)
           
abstract  int Module.restrictTrans(BDD temp_trans)
           
 void SMVModule.setInitial(BDD to_add)
           
 void FDSModule.setInitial(BDD to_add)
           
abstract  void Module.setInitial(BDD to_add)
           Set the initial condition with the given condition.
 BDD[] Module.shortestPath(BDD source, BDD dest)
           Compute the shortest path from source to destination.
 BDD Module.succ(BDD from)
           This procedure return all states which the module can reach in a single step from given a set of state.
 BDD Module.yieldStates(Module responder, BDD to)
           A state s in included in the returning result if responder module can force this module to reach a state in "to".
That is, regardless of how this module will move from the result, the responder module can choose an appropriate move into "to".
 

Method parameters in edu.wis.jtlv.env.module with type arguments of type BDD
 void SMVModule.setAllIniRestrictions(java.util.Vector<BDD> toSet)
           
 void FDSModule.setAllIniRestrictions(java.util.Vector<BDD> toSet)
           
abstract  void Module.setAllIniRestrictions(java.util.Vector<BDD> toSet)
           
 void SMVModule.setAllTransRestrictions(java.util.Vector<BDD> toSet)
           
 void FDSModule.setAllTransRestrictions(java.util.Vector<BDD> toSet)
           
abstract  void Module.setAllTransRestrictions(java.util.Vector<BDD> toSet)
           
 

Uses of BDD in edu.wis.jtlv.env.spec
 

Methods in edu.wis.jtlv.env.spec that return BDD
 BDD SpecBDD.getVal()
           
 BDD SpecCTLRange.toBDD()
           
 BDD SpecExp.toBDD()
           
 BDD Spec.toBDD()
           
 BDD SpecBDD.toBDD()
           
 

Constructors in edu.wis.jtlv.env.spec with parameters of type BDD
SpecBDD(BDD v)
           
SpecBDD(java.lang.String identifying_expr, BDD v)
           
 

Uses of BDD in edu.wis.jtlv.lib.old.games
 

Fields in edu.wis.jtlv.lib.old.games declared as BDD
 BDD MyPair.bdd
           
 BDD RkGame.ImplicationEntity.g
           
 BDD RkGame.ImplicationEntity.r
           
 BDD[][][] GR1Game.x_mem
           
 BDD[][] GR1Game.y_mem
           
 BDD[] GR1Game.z_mem
           
 

Methods in edu.wis.jtlv.lib.old.games that return BDD
 BDD RkGame.envWinningStates()
           Getter for the system's winning states.
 BDD GR1Game.envWinningStates()
           Getter for the system's winning states.
 BDD GR1Game.firstPlayersWinningStates()
           
 BDD TwoPlayersGame.firstPlayersWinningStates()
           
 BDD RkGame.gameInitials()
           
 BDD GR1Game.gameInitials()
           
 BDD Game.gameInitials()
           
 BDD RkGame.m_Streett(BDD seqng, BDD rest)
           
 BDD Memory.next_contained(BDD target)
           
 BDD Memory.next_intersect(BDD current, BDD target, Memory.Permutation perm, Memory.Permutation loc)
           
 BDD[] RkGame.playersWinningStates()
           
 BDD[] GR1Game.playersWinningStates()
           
 BDD[] Game.playersWinningStates()
           
 BDD Memory.recursive_next_intersect(BDD current, BDD target, Memory.Permutation perm, Memory.Permutation loc, int ind)
           
 BDD GR1Game.secondPlayersWinningStates()
           
 BDD TwoPlayersGame.secondPlayersWinningStates()
           
 BDD RkGame.sysWinningStates()
           Getter for the environment's winning states.
 BDD GR1Game.sysWinningStates()
           Getter for the environment's winning states.
 

Methods in edu.wis.jtlv.lib.old.games with parameters of type BDD
 boolean Memory.find_intersect(BDD target, Memory.Permutation perm, Memory.Permutation loc)
           
 void Memory.insert(RkGame.ImplicationEntity pair, int pair_ind, int location, BDD new_bdd, Memory new_memory)
           
 BDD RkGame.m_Streett(BDD seqng, BDD rest)
           
 BDD Memory.next_contained(BDD target)
           
 BDD Memory.next_intersect(BDD current, BDD target, Memory.Permutation perm, Memory.Permutation loc)
           
 boolean Memory.recursive_find_intersect(BDD target, Memory.Permutation perm, Memory.Permutation loc, int ind)
           
 BDD Memory.recursive_next_intersect(BDD current, BDD target, Memory.Permutation perm, Memory.Permutation loc, int ind)
           
 

Constructors in edu.wis.jtlv.lib.old.games with parameters of type BDD
MyPair(BDD bdd, Memory mem)
           
RkGame.ImplicationEntity(BDD g, BDD r)
           
 

Uses of BDD in edu.wis.jtlv.lib.old.mc
 

Methods in edu.wis.jtlv.lib.old.mc that return BDD
 BDD[] CounterExampleException.getPath()
           
 BDD LTLModelChecker.LTLTesterBuilder.getSpec2BDD(Spec root)
           
 

Constructors in edu.wis.jtlv.lib.old.mc with parameters of type BDD
CounterExampleException(java.lang.String desc, BDD[] path)
           
 

Uses of BDD in net.sf.javabdd
 

Subclasses of BDD in net.sf.javabdd
 class BDDFactoryIntImpl.IntBDD
           
 class BDDFactoryIntImpl.IntBDDWithFinalizer
           
 class TypedBDDFactory.TypedBDD
          A BDD with types (domains) attached to it.
 

Methods in net.sf.javabdd that return BDD
 BDD BDD.and(BDD that)
          Returns the logical 'and' of two BDDs.
 BDD BDD.andWith(BDD that)
          Makes this BDD be the logical 'and' of two BDDs.
abstract  BDD BDD.apply(BDD that, BDDFactory.BDDOp opr)
          Returns the result of applying the binary operator opr to the two BDDs.
 BDD TypedBDDFactory.TypedBDD.apply(BDD that, BDDFactory.BDDOp opr)
           
 BDD BDDFactoryIntImpl.IntBDD.apply(BDD that, BDDFactory.BDDOp opr)
           
abstract  BDD BDD.applyAll(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
          Applies the binary operator opr to two BDDs and then performs a universal quantification of the variables from the variable set var.
 BDD TypedBDDFactory.TypedBDD.applyAll(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.applyAll(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
abstract  BDD BDD.applyEx(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
          Applies the binary operator opr to two BDDs and then performs an existential quantification of the variables from the variable set var.
 BDD TypedBDDFactory.TypedBDD.applyEx(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.applyEx(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
abstract  BDD BDD.applyUni(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
          Applies the binary operator opr to two BDDs and then performs a unique quantification of the variables from the variable set var.
 BDD TypedBDDFactory.TypedBDD.applyUni(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.applyUni(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
abstract  BDD BDD.applyWith(BDD that, BDDFactory.BDDOp opr)
          Makes this BDD be the result of the binary operator opr of two BDDs.
 BDD TypedBDDFactory.TypedBDD.applyWith(BDD that, BDDFactory.BDDOp opr)
           
 BDD BDDFactoryIntImpl.IntBDD.applyWith(BDD that, BDDFactory.BDDOp opr)
           
 BDD BDD.biimp(BDD that)
          Returns the logical 'bi-implication' of two BDDs.
 BDD BDD.biimpWith(BDD that)
          Makes this BDD be the logical 'bi-implication' of two BDDs.
 BDD BDDDomain.buildAdd(BDDDomain that, int bits, long value)
           
 BDD BDDDomain.buildAdd(BDDDomain that, long value)
           
 BDD BDDFactory.buildCube(int value, int[] variables)
          Build a cube from an array of variables.
 BDD BDDFactory.buildCube(int value, java.util.List variables)
          Build a cube from an array of variables.
 BDD BDDDomain.buildEquals(BDDDomain that)
          Builds a BDD which is true for all the possible assignments to the variable blocks that makes the blocks equal.
abstract  BDD BDD.compose(BDD g, int var)
          Functional composition.
 BDD TypedBDDFactory.TypedBDD.compose(BDD g, int var)
           
 BDD BDDFactoryIntImpl.IntBDD.compose(BDD g, int var)
           
abstract  BDD BDD.constrain(BDD that)
          Generalized cofactor.
 BDD TypedBDDFactory.TypedBDD.constrain(BDD that)
           
 BDD BDDFactoryIntImpl.IntBDD.constrain(BDD that)
           
 BDD MicroFactory.copyNode(BDD that)
          Use this function to translate BDD's from a JavaFactory into its clone.
 BDD JFactory.copyNode(BDD that)
          Use this function to translate BDD's from a JavaFactory into its clone.
 BDD BDDDomain.domain()
          Returns what corresponds to a disjunction of all possible values of this domain.
abstract  BDD BDD.exist(BDDVarSet var)
          Existential quantification of variables.
 BDD TypedBDDFactory.TypedBDD.exist(BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.exist(BDDVarSet var)
           
abstract  BDD BDD.forAll(BDDVarSet var)
          Universal quantification of variables.
 BDD TypedBDDFactory.TypedBDD.forAll(BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.forAll(BDDVarSet var)
           
abstract  BDD BDD.fullSatOne()
          Finds one satisfying variable assignment.
 BDD TypedBDDFactory.TypedBDD.fullSatOne()
           
 BDD BDDFactoryIntImpl.IntBDD.fullSatOne()
           
 BDD BDDBitVector.getBit(int n)
           
abstract  BDD BDD.high()
          Gets the true branch of this BDD.
 BDD TypedBDDFactory.TypedBDD.high()
           
 BDD BDDFactoryIntImpl.IntBDD.high()
           
abstract  BDD BDD.id()
          Identity function.
 BDD TypedBDDFactory.TypedBDD.id()
           
 BDD BDDFactoryIntImpl.IntBDD.id()
           
 BDD BDD.imp(BDD that)
          Returns the logical 'implication' of two BDDs.
 BDD BDD.impWith(BDD that)
          Makes this BDD be the logical 'implication' of two BDDs.
abstract  BDD BDD.ite(BDD thenBDD, BDD elseBDD)
          if-then-else operator.
 BDD TypedBDDFactory.TypedBDD.ite(BDD thenBDD, BDD elseBDD)
           
 BDD BDDFactoryIntImpl.IntBDD.ite(BDD thenBDD, BDD elseBDD)
           
 BDD BDDDomain.ithVar(java.math.BigInteger val)
           
 BDD CALFactory.ithVar(int var)
           
 BDD TypedBDDFactory.ithVar(int var)
           
 BDD BDDFactoryIntImpl.ithVar(int var)
           
abstract  BDD BDDFactory.ithVar(int var)
          Returns a BDD representing the I'th variable.
 BDD CUDDFactory.ithVar(int var)
           
 BDD TestBDDFactory.ithVar(int var)
           
 BDD BDDDomain.ithVar(long val)
          Returns the BDD that defines the given value for this finite domain block.
 BDD BDDFactory.load(java.io.BufferedReader ifile)
          Loads a BDD from the given input.
 BDD MicroFactory.load(java.io.BufferedReader in, int[] translate)
           
 BDD JFactory.load(java.io.BufferedReader in, int[] translate)
           
 BDD BDDFactory.load(java.io.BufferedReader ifile, int[] translate)
          Loads a BDD from the given input, translating BDD variables according to the given map.
 BDD UberMicroFactory.load(java.io.BufferedReader in, int[] translate)
           
 BDD TypedBDDFactory.load(java.lang.String filename)
           
 BDD BuDDyFactory.load(java.lang.String filename)
           
 BDD BDDFactory.load(java.lang.String filename)
          Loads a BDD from a file.
 BDD TestBDDFactory.load(java.lang.String filename)
           
abstract  BDD BDD.low()
          Gets the false branch of this BDD.
 BDD TypedBDDFactory.TypedBDD.low()
           
 BDD BDDFactoryIntImpl.IntBDD.low()
           
 BDD BDD.BDDIterator.nextBDD()
          Return the next BDD in the iteration.
 BDD CALFactory.nithVar(int var)
           
 BDD TypedBDDFactory.nithVar(int var)
           
 BDD BDDFactoryIntImpl.nithVar(int var)
           
abstract  BDD BDDFactory.nithVar(int var)
          Returns a BDD representing the negation of the I'th variable.
 BDD CUDDFactory.nithVar(int var)
           
 BDD TestBDDFactory.nithVar(int var)
           
abstract  BDD BDD.not()
          Negates this BDD by exchanging all references to the zero-terminal with references to the one-terminal and vice-versa.
 BDD TypedBDDFactory.TypedBDD.not()
           
 BDD BDDFactoryIntImpl.IntBDD.not()
           
 BDD CALFactory.one()
           
 BDD TypedBDDFactory.one()
           
 BDD BDDFactoryIntImpl.one()
           
abstract  BDD BDDFactory.one()
          Get the constant true BDD.
 BDD CUDDFactory.one()
           
 BDD TestBDDFactory.one()
           
 BDD BDD.or(BDD that)
          Returns the logical 'or' of two BDDs.
 BDD BDD.orWith(BDD that)
          Makes this BDD be the logical 'or' of two BDDs.
 BDD BDD.relprod(BDD that, BDDVarSet var)
          Relational product.
 BDD TypedBDDFactory.TypedBDD.relprod(BDD that, BDDVarSet var)
           
abstract  BDD BDD.replace(BDDPairing pair)
          Returns a BDD where all variables are replaced with the variables defined by pair.
 BDD TypedBDDFactory.TypedBDD.replace(BDDPairing pair)
           
 BDD BDDFactoryIntImpl.IntBDD.replace(BDDPairing pair)
           
abstract  BDD BDD.replaceWith(BDDPairing pair)
          Replaces all variables in this BDD with the variables defined by pair.
 BDD TypedBDDFactory.TypedBDD.replaceWith(BDDPairing pair)
           
 BDD BDDFactoryIntImpl.IntBDD.replaceWith(BDDPairing pair)
           
abstract  BDD BDD.restrict(BDD var)
          Restrict a set of variables to constant values.
 BDD TypedBDDFactory.TypedBDD.restrict(BDD var)
           
 BDD BDDFactoryIntImpl.IntBDD.restrict(BDD var)
           
abstract  BDD BDD.restrictWith(BDD var)
          Mutates this BDD to restrict a set of variables to constant values.
 BDD TypedBDDFactory.TypedBDD.restrictWith(BDD var)
           
 BDD BDDFactoryIntImpl.IntBDD.restrictWith(BDD that)
           
abstract  BDD BDD.satOne()
          Finds one satisfying variable assignment.
 BDD TypedBDDFactory.TypedBDD.satOne()
           
 BDD BDDFactoryIntImpl.IntBDD.satOne()
           
abstract  BDD BDD.satOne(BDDVarSet var, boolean pol)
          Finds one satisfying variable assignment.
 BDD TypedBDDFactory.TypedBDD.satOne(BDDVarSet var, boolean pol)
           
 BDD BDDFactoryIntImpl.IntBDD.satOne(BDDVarSet var, boolean pol)
           
abstract  BDD BDD.simplify(BDDVarSet d)
          Coudert and Madre's restrict function.
 BDD TypedBDDFactory.TypedBDD.simplify(BDDVarSet d)
           
 BDD BDDFactoryIntImpl.IntBDD.simplify(BDDVarSet d)
           
abstract  BDD BDDVarSet.toBDD()
           
 BDD BDDVarSet.DefaultImpl.toBDD()
           
 BDD TypedBDDFactory.TypedBDDVarSet.toBDD()
           
 BDD BDDFactoryIntImpl.IntBDDVarSet.toBDD()
           
abstract  BDD BDD.unique(BDDVarSet var)
          Unique quantification of variables.
 BDD TypedBDDFactory.TypedBDD.unique(BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.unique(BDDVarSet var)
           
 BDD BDDFactoryIntImpl.universe()
           
 BDD BDDFactory.universe()
          Get the constant universe BDD.
 BDD TestBDDFactory.universe()
           
 BDD BDDDomain.varRange(java.math.BigInteger lo, java.math.BigInteger hi)
           
 BDD BDDDomain.varRange(long lo, long hi)
          Returns the BDD that defines the given range of values, inclusive, for this finite domain block.
abstract  BDD BDD.veccompose(BDDPairing pair)
          Simultaneous functional composition.
 BDD TypedBDDFactory.TypedBDD.veccompose(BDDPairing pair)
           
 BDD BDDFactoryIntImpl.IntBDD.veccompose(BDDPairing pair)
           
 BDD BDD.xor(BDD that)
          Returns the logical 'xor' of two BDDs.
 BDD BDD.xorWith(BDD that)
          Makes this BDD be the logical 'xor' of two BDDs.
 BDD CALFactory.zero()
           
 BDD TypedBDDFactory.zero()
           
 BDD BDDFactoryIntImpl.zero()
           
abstract  BDD BDDFactory.zero()
          Get the constant false BDD.
 BDD CUDDFactory.zero()
           
 BDD TestBDDFactory.zero()
           
 

Methods in net.sf.javabdd with parameters of type BDD
 void CALFactory.addVarBlock(BDD var, boolean fixed)
           
 void CUDDFactory.addVarBlock(BDD var, boolean fixed)
           
 BDD BDD.and(BDD that)
          Returns the logical 'and' of two BDDs.
 BDD BDD.andWith(BDD that)
          Makes this BDD be the logical 'and' of two BDDs.
abstract  BDD BDD.apply(BDD that, BDDFactory.BDDOp opr)
          Returns the result of applying the binary operator opr to the two BDDs.
 BDD TypedBDDFactory.TypedBDD.apply(BDD that, BDDFactory.BDDOp opr)
           
 BDD BDDFactoryIntImpl.IntBDD.apply(BDD that, BDDFactory.BDDOp opr)
           
abstract  BDD BDD.applyAll(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
          Applies the binary operator opr to two BDDs and then performs a universal quantification of the variables from the variable set var.
 BDD TypedBDDFactory.TypedBDD.applyAll(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.applyAll(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
abstract  BDD BDD.applyEx(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
          Applies the binary operator opr to two BDDs and then performs an existential quantification of the variables from the variable set var.
 BDD TypedBDDFactory.TypedBDD.applyEx(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.applyEx(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
abstract  BDD BDD.applyUni(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
          Applies the binary operator opr to two BDDs and then performs a unique quantification of the variables from the variable set var.
 BDD TypedBDDFactory.TypedBDD.applyUni(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
 BDD BDDFactoryIntImpl.IntBDD.applyUni(BDD that, BDDFactory.BDDOp opr, BDDVarSet var)
           
abstract  BDD BDD.applyWith(BDD that, BDDFactory.BDDOp opr)
          Makes this BDD be the result of the binary operator opr of two BDDs.
 BDD TypedBDDFactory.TypedBDD.applyWith(BDD that, BDDFactory.BDDOp opr)
           
 BDD BDDFactoryIntImpl.IntBDD.applyWith(BDD that, BDDFactory.BDDOp opr)
           
static void TestBDDFactory.assertSame(BDD b1, BDD b2, java.lang.String s)
           
static void TestBDDFactory.assertSame(boolean b, BDD b1, BDD b2, java.lang.String s)
           
 BDD BDD.biimp(BDD that)
          Returns the logical 'bi-implication' of two BDDs.
 BDD BDD.biimpWith(BDD that)
          Makes this BDD be the logical 'bi-implication' of two BDDs.
abstract  BDD BDD.compose(BDD g, int var)
          Functional composition.
 BDD TypedBDDFactory.TypedBDD.compose(BDD g, int var)
           
 BDD BDDFactoryIntImpl.IntBDD.compose(BDD g, int var)
           
abstract  BDD BDD.constrain(BDD that)
          Generalized cofactor.
 BDD TypedBDDFactory.TypedBDD.constrain(BDD that)
           
 BDD BDDFactoryIntImpl.IntBDD.constrain(BDD that)
           
 BDD MicroFactory.copyNode(BDD that)
          Use this function to translate BDD's from a JavaFactory into its clone.
 BDD JFactory.copyNode(BDD that)
          Use this function to translate BDD's from a JavaFactory into its clone.
abstract  boolean BDD.equals(BDD that)
          Returns true if this BDD equals that BDD, false otherwise.
 boolean TypedBDDFactory.TypedBDD.equals(BDD that)
           
 boolean BDDFactoryIntImpl.IntBDD.equals(BDD that)
           
 java.math.BigInteger[] BDDDomain.getVarIndices(BDD bdd)
          Convert a BDD that to a list of indices of this domain.
 java.math.BigInteger[] BDDDomain.getVarIndices(BDD bdd, int max)
          Convert a BDD that to a list of indices of this domain.
 BDD BDD.imp(BDD that)
          Returns the logical 'implication' of two BDDs.
 BDD BDD.impWith(BDD that)
          Makes this BDD be the logical 'implication' of two BDDs.
 void TryVarOrder.init(BDD b1, BDD b2, BDD dom, BDDFactory.BDDOp op)
          Initialize for a new trial.
 void FindBestOrder.init(BDD b1, BDD b2, BDDVarSet dom, BDDFactory.BDDOp op)
           
abstract  BDD BDD.ite(BDD thenBDD, BDD elseBDD)
          if-then-else operator.
 BDD TypedBDDFactory.TypedBDD.ite(BDD thenBDD, BDD elseBDD)
           
 BDD BDDFactoryIntImpl.IntBDD.ite(BDD thenBDD, BDD elseBDD)
           
 BDDPairing BDDFactory.makePair(int oldvar, BDD newvar)
          Make a new pairing that maps from one variable to another BDD.
 BDD BDD.or(BDD that)
          Returns the logical 'or' of two BDDs.
 BDD BDD.orWith(BDD that)
          Makes this BDD be the logical 'or' of two BDDs.
 void CALFactory.printTable(BDD b)
           
 void TypedBDDFactory.printTable(BDD b)
           
 void BDDFactoryIntImpl.printTable(BDD b)
           
abstract  void BDDFactory.printTable(BDD b)
          Prints the node table entries used by a BDD.
 void CUDDFactory.printTable(BDD b)
           
 void TestBDDFactory.printTable(BDD b)
           
 BDD BDD.relprod(BDD that, BDDVarSet var)
          Relational product.
 BDD TypedBDDFactory.TypedBDD.relprod(BDD that, BDDVarSet var)
           
abstract  BDD BDD.restrict(BDD var)
          Restrict a set of variables to constant values.
 BDD TypedBDDFactory.TypedBDD.restrict(BDD var)
           
 BDD BDDFactoryIntImpl.IntBDD.restrict(BDD var)
           
abstract  BDD BDD.restrictWith(BDD var)
          Mutates this BDD to restrict a set of variables to constant values.
 BDD TypedBDDFactory.TypedBDD.restrictWith(BDD var)
           
 BDD BDDFactoryIntImpl.IntBDD.restrictWith(BDD that)
           
 void MicroFactory.save(java.io.BufferedWriter out, BDD b)
           
 void JFactory.save(java.io.BufferedWriter out, BDD b)
           
 void BDDFactory.save(java.io.BufferedWriter out, BDD r)
          Saves a BDD to an output writer.
 void UberMicroFactory.save(java.io.BufferedWriter out, BDD b)
           
 void TypedBDDFactory.save(java.lang.String filename, BDD var)
           
 void BuDDyFactory.save(java.lang.String filename, BDD b)
           
 void BDDFactory.save(java.lang.String filename, BDD var)
          Saves a BDD to a file.
 void TestBDDFactory.save(java.lang.String filename, BDD var)
           
 void BDDPairing.set(int[] oldvar, BDD[] newvar)
          Like set(), but with a whole list of pairs.
abstract  void BDDPairing.set(int oldvar, BDD newvar)
          Adds the pair (oldvar, newvar) to this table of pairs.
 BDDBitVector BDDBitVector.shl(int pos, BDD c)
           
 void MicroFactory.validateBDD(BDD b)
           
 void JFactory.validateBDD(BDD b)
           
 void UberMicroFactory.validateBDD(BDD b)
           
 BDD BDD.xor(BDD that)
          Returns the logical 'xor' of two BDDs.
 BDD BDD.xorWith(BDD that)
          Makes this BDD be the logical 'xor' of two BDDs.
 

Constructors in net.sf.javabdd with parameters of type BDD
BDD.AllSatIterator(BDD r)
          Constructs a satisfying-assignment iterator on the given BDD.
BDD.AllSatIterator(BDD r, boolean lev)
          Constructs a satisfying-assignment iterator on the given BDD.
BDD.BDDIterator(BDD bdd, BDDVarSet var)
          Construct a new BDDIterator on the given BDD.
BDDVarSet.DefaultImpl(BDD b)
          Construct a BDDVarSet backed by the given BDD.
TypedBDDFactory.TypedBDD(BDD bdd, java.util.Set dom)