|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |