|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use MvSet | |
---|---|
edu.toronto.cs.ctl | CTL Abstract Syntax Tree |
edu.toronto.cs.gclang.parser | ANTLR parser for GCLang |
edu.toronto.cs.modelchecker | Basic CTL model-checking engine based on MvSet |
edu.toronto.cs.mvset | Provides several symbolic implementations of multi-valued sets |
edu.toronto.cs.proof | Provides classes for representing, manipulating, and constructing proofs for CTL formulas (OLD) |
edu.toronto.cs.proof2 | Provides classes for representing, manipulating, and constructing proofs for CTL formulas (NEW) |
edu.toronto.cs.simulator | A model simulator for XChek (Victor). |
edu.toronto.cs.smv | Provides classes to represent SMV models |
edu.toronto.cs.smv.parser | ANTLR parsers for SMV models |
edu.toronto.cs.tlq | Classes used by TLQSolver extension of XChek |
edu.toronto.cs.xkripke | Classes to represent, manipulate, and parse XML representation of XKripke structures. |
Uses of MvSet in edu.toronto.cs.ctl |
---|
Methods in edu.toronto.cs.ctl that return MvSet | |
---|---|
MvSet |
CTLMvSetNode.getMvSet()
|
MvSet |
CTLAtomPropNode.getMvSet()
|
MvSet[] |
CTLPlaceholderNode.getTerm(int i)
|
MvSet[][] |
CTLPlaceholderNode.getTerms()
|
Methods in edu.toronto.cs.ctl with parameters of type MvSet | |
---|---|
static CTLMvSetNode |
CTLFactory.createCTLMvSetNode(MvSet mvset)
|
static CTLTransitionNode |
CTLFactory.createCTLTransitionNode(MvSet mvset)
|
void |
CTLAtomPropNode.setMvSet(MvSet v)
|
void |
CTLPlaceholderNode.setTerms(MvSet[][] v)
|
Constructors in edu.toronto.cs.ctl with parameters of type MvSet | |
---|---|
CTLAtomPropNode(java.lang.String _name,
MvSet value)
|
|
CTLMvSetNode(MvSet set)
Construct a CTL node associated with a particular MvSet. |
|
CTLTransitionNode(MvSet set)
|
Uses of MvSet in edu.toronto.cs.gclang.parser |
---|
Methods in edu.toronto.cs.gclang.parser that return MvSet | |
---|---|
MvSet |
GCLangBuilder.assign(antlr.collections.AST _t)
|
MvSet |
GCLangBuilder.atomicCommand(antlr.collections.AST _t)
|
MvSet |
GCLangBuilder.command(antlr.collections.AST _t)
|
abstract MvSet |
VariableTable.Variable.eq(MvSet v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(MvSet v)
|
MvSet |
VariableTable.StateVariable.eq(MvSet v)
|
abstract MvSet |
VariableTable.Variable.eq(java.lang.String v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(java.lang.String v)
|
MvSet |
VariableTable.StateVariable.eq(java.lang.String v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(VariableTable.EnumeratedVariable v)
|
MvSet |
VariableTable.StateVariable.eq(VariableTable.StateVariable v)
|
abstract MvSet |
VariableTable.Variable.eq(VariableTable.Variable v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(VariableTable.Variable v)
|
MvSet |
VariableTable.StateVariable.eq(VariableTable.Variable v)
|
abstract MvSet |
VariableTable.Variable.eqShadow(int i)
|
MvSet |
VariableTable.EnumeratedVariable.eqShadow(int idx)
|
MvSet |
VariableTable.StateVariable.eqShadow(int idx)
|
MvSet |
GCLangBuilder.expression(antlr.collections.AST _t)
|
MvSet |
GCLangCompiler.getInit()
|
MvSet |
VariableTable.StateVariable.getMvSet()
|
protected MvSet |
GCLangBuilder.guard(antlr.collections.AST _t)
|
MvSet |
GCLangBuilder.guardedCommand(antlr.collections.AST _t)
|
MvSet |
GCLangBuilder.ite(antlr.collections.AST _t)
|
MvSet |
GCLangBuilder.skip(antlr.collections.AST _t)
|
Methods in edu.toronto.cs.gclang.parser with parameters of type MvSet | |
---|---|
VariableTable.DefineVariable |
VariableTable.declareDefine(java.lang.String name,
MvSet value)
Describe declareDefine method here. |
abstract MvSet |
VariableTable.Variable.eq(MvSet v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(MvSet v)
|
MvSet |
VariableTable.StateVariable.eq(MvSet v)
|
protected void |
VariableTable.StateVariable.setMvSet(MvSet v)
|
Constructors in edu.toronto.cs.gclang.parser with parameters of type MvSet | |
---|---|
VariableTable.DefineVariable(java.lang.String name,
MvSet value)
|
Uses of MvSet in edu.toronto.cs.modelchecker |
---|
Methods in edu.toronto.cs.modelchecker that return MvSet | |
---|---|
MvSet |
MvSetModelChecker.__checkCTL(CTLNode ctl,
MvSet init)
|
MvSet |
MvSetModelChecker.checkCTL(CTLNode v)
|
MvSet |
MvSetModelChecker.checkCTL(CTLNode ctl,
MvSet state)
|
MvSet |
XKripkeStructure.getInit()
|
MvSet |
XKripkeStructure.getPrimeCube()
|
MvSet |
XKripkeStructure.getUnPrimeCube()
|
MvSet |
MvSetModelChecker.getUnPrimeCube()
|
Methods in edu.toronto.cs.modelchecker with parameters of type MvSet | |
---|---|
MvSet |
MvSetModelChecker.__checkCTL(CTLNode ctl,
MvSet init)
|
MvSet |
MvSetModelChecker.checkCTL(CTLNode ctl,
MvSet state)
|
CTLNode[] |
StatePresenter.toCTL(MvSet cube)
|
Constructors in edu.toronto.cs.modelchecker with parameters of type MvSet | |
---|---|
CTLUntilExpander(MvSet _top)
|
|
XKripkeStructure(MvRelation _trans,
MvSet _init,
int[] _prime,
MvSet _primeCube,
MvSet _unPrimeCube,
java.lang.String[] _varNames,
IAlgebra _algebra,
int _numDDVars,
int _numVars,
CTLReWriter _rewriter,
StatePresenter _statePresenter)
|
|
XKripkeStructure(MvRelation _trans,
MvSet _init,
int[] _prime,
MvSet _primeCube,
MvSet _unPrimeCube,
java.lang.String[] _varNames,
IAlgebra _algebra,
int _numDDVars,
int _numVars,
CTLReWriter _rewriter,
StatePresenter _statePresenter,
java.lang.String _name)
|
Uses of MvSet in edu.toronto.cs.mvset |
---|
Classes in edu.toronto.cs.mvset that implement MvSet | |
---|---|
class |
AbstractMvSet
|
class |
CUADDMvSetFactory.CUADDMvSet
|
class |
JADDMvSetFactory.JADDMvSet
|
class |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet
|
class |
JCUDDMvSetFactory.JCUDDMvSet
|
class |
MDDMvSetFactory.MDDMvSet
|
Methods in edu.toronto.cs.mvset that return MvSet | |
---|---|
MvSet |
AbstractMvSet.and(MvSet v)
Utility functions |
MvSet |
MvSet.and(MvSet v)
Utility functions |
MvSet |
JCUDDMvSetFactory.bot()
|
MvSet |
MvSetFactory.bot()
|
MvSet |
JCUDDBelnapMvSetFactory.bot()
|
MvSet |
MDDMvSetFactory.bot()
|
MvSet |
JADDMvSetFactory.bot()
|
MvSet |
CUADDMvSetFactory.bot()
|
MvSet |
JCUDDMvSetFactory.buildCube(int[] varIndex)
|
MvSet |
MvSetFactory.buildCube(int[] varIndex)
builds a cube out of variables |
MvSet |
JCUDDBelnapMvSetFactory.buildCube(int[] varIndex)
|
MvSet |
MDDMvSetFactory.buildCube(int[] varIndex)
|
MvSet |
JADDMvSetFactory.buildCube(int[] varIndex)
|
MvSet |
CUADDMvSetFactory.buildCube(int[] varIndex)
|
MvSet |
MvRelation.bwdImage(MvSet v)
Computes the backward image (a.k.a, pre, EX) of v . |
MvSet |
SeqMvRelation.bwdImage(MvSet v)
|
MvSet |
MvSetMvRelation.bwdImage(MvSet v)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.cofactor(AlgebraValue[] r)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(AlgebraValue[] r)
|
MvSet |
MDDMvSetFactory.MDDMvSet.cofactor(AlgebraValue[] r)
|
MvSet |
JADDMvSetFactory.JADDMvSet.cofactor(AlgebraValue[] r)
|
MvSet |
MvSet.cofactor(AlgebraValue[] r)
Restricts the MvSet to a particular L^n (or set of permutations on L^n if r is not total) |
MvSet |
CUADDMvSetFactory.CUADDMvSet.cofactor(AlgebraValue[] r)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.cofactor(int argIdx,
AlgebraValue value)
Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx |
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(int argIdx,
AlgebraValue value)
Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx |
MvSet |
MDDMvSetFactory.MDDMvSet.cofactor(int argIdx,
AlgebraValue value)
Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx |
MvSet |
JADDMvSetFactory.JADDMvSet.cofactor(int argIdx,
AlgebraValue value)
Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx |
MvSet |
MvSet.cofactor(int argIdx,
AlgebraValue value)
Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx |
MvSet |
CUADDMvSetFactory.CUADDMvSet.cofactor(int argIdx,
AlgebraValue value)
Restricts an argument h (x_0, x_1, x_2, ...) = f (x_0, ..., value, ...) where value is substituted at argIdx |
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.cofactor(MvSet cube)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(MvSet cube)
|
MvSet |
MDDMvSetFactory.MDDMvSet.cofactor(MvSet point)
|
MvSet |
AbstractMvSet.cofactor(MvSet point)
|
MvSet |
MvSet.cofactor(MvSet point)
|
MvSet |
JCUDDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
MvSetFactory.createCase(int argIdx,
MvSet[] children)
createCase creates a case relative to argIdx
this is somewhat simillar to Ite (if-then-else) in CUDD
but extended to more than two children. |
MvSet |
JCUDDBelnapMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
MDDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
JADDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
CUADDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
JCUDDMvSetFactory.createConstant(AlgebraValue v)
Given a value in L creates a function f(x_0, x_1, ...) = value |
MvSet |
MvSetFactory.createConstant(AlgebraValue value)
Given a value in L creates a function f(x_0, x_1, ...) = value |
MvSet |
JCUDDBelnapMvSetFactory.createConstant(AlgebraValue v)
Given a value in L creates a function f(x_0, x_1, ...) = value |
MvSet |
MDDMvSetFactory.createConstant(AlgebraValue v)
Given a value in L creates a function f(x_0, x_1, ...) = value |
MvSet |
JADDMvSetFactory.createConstant(AlgebraValue v)
Given a value in L creates a function f(x_0, x_1, ...) = value |
MvSet |
CUADDMvSetFactory.createConstant(AlgebraValue v)
Given a value in L creates a function f(x_0, x_1, ...) = value |
MvSet |
JCUDDMvSetFactory.createIte(int argIdx,
MvSet child0,
MvSet child1)
|
MvSet |
JCUDDBelnapMvSetFactory.createIte(int argIdx,
MvSet child0,
MvSet child1)
|
MvSet |
CUADDMvSetFactory.createIte(int argIdx,
MvSet child0,
MvSet child1)
|
MvSet |
CUADDMvSetFactory.createMvSet(CuddAdd.ADD addNode)
|
MvSet |
JCUDDMvSetFactory.createMvSet(int cPtr)
|
MvSet |
JCUDDBelnapMvSetFactory.createMvSet(int cPtr)
|
MvSet |
MDDMvSetFactory.createMvSet(MDDNode mddNode)
|
MvSet |
JADDMvSetFactory.createMvSet(MDDNode mddNode)
|
MvSet |
JCUDDMvSetFactory.createPoint(AlgebraValue[] args,
AlgebraValue value)
Creates a point function f (args) = value = 0 otherwise |
MvSet |
MvSetFactory.createPoint(AlgebraValue[] args,
AlgebraValue value)
Creates a point function f (args) = value = 0 otherwise |
MvSet |
JCUDDBelnapMvSetFactory.createPoint(AlgebraValue[] args,
AlgebraValue value)
Creates a point function f (args) = value = 0 otherwise |
MvSet |
MDDMvSetFactory.createPoint(AlgebraValue[] args,
AlgebraValue value)
Creates a point function f (args) = value = 0 otherwise |
MvSet |
JADDMvSetFactory.createPoint(AlgebraValue[] args,
AlgebraValue value)
Creates a point function f (args) = value = 0 otherwise |
MvSet |
CUADDMvSetFactory.createPoint(AlgebraValue[] args,
AlgebraValue value)
Creates a point function f (args) = value = 0 otherwise |
MvSet |
JCUDDMvSetFactory.createProjection(int argIdx)
Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx |
MvSet |
MvSetFactory.createProjection(int argIdx)
Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx |
MvSet |
JCUDDBelnapMvSetFactory.createProjection(int argIdx)
Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx |
MvSet |
MDDMvSetFactory.createProjection(int argIdx)
Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx |
MvSet |
JADDMvSetFactory.createProjection(int argIdx)
Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx |
MvSet |
CUADDMvSetFactory.createProjection(int argIdx)
Given an argument index (0 <= argIdx < n) constructs a projection function f(x_0, x_1, ...) = x_argIdx |
MvSet |
MvRelation.dualBwdImage(MvSet v)
Computes the logical dual of backward image (a.k.a. |
MvSet |
SeqMvRelation.dualBwdImage(MvSet v)
|
MvSet |
MvSetMvRelation.dualBwdImage(MvSet v)
|
MvSet |
AbstractMvSet.eq(MvSet v)
|
MvSet |
MvSet.eq(MvSet v)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.existAbstract(MvSet _cube)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.existAbstract(MvSet _cube)
|
MvSet |
MDDMvSetFactory.MDDMvSet.existAbstract(MvSet _cube)
|
MvSet |
JADDMvSetFactory.JADDMvSet.existAbstract(MvSet _cube)
|
MvSet |
MvSet.existAbstract(MvSet cube)
|
MvSet |
CUADDMvSetFactory.CUADDMvSet.existAbstract(MvSet _cube)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.forallAbstract(MvSet _cube)
|
MvSet |
MDDMvSetFactory.MDDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
JADDMvSetFactory.JADDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
MvSet.forallAbstract(MvSet cube)
|
MvSet |
CUADDMvSetFactory.CUADDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
MvRelation.fwdImage(MvSet v)
Computes forward image (post) of v |
MvSet |
SeqMvRelation.fwdImage(MvSet v)
|
MvSet |
MvSetMvRelation.fwdImage(MvSet v)
|
MvSet |
AbstractMvSet.geq(MvSet v)
|
MvSet |
MvSet.geq(MvSet v)
|
MvSet |
MvRelation.getPostVariablesCube()
get cube of post-state variables |
MvSet |
SeqMvRelation.getPostVariablesCube()
get cube of post-state variables |
MvSet |
MvSetMvRelation.getPostVariablesCube()
get cube of post-state variables |
MvSet |
MvRelation.getPreVariablesCube()
return cube of pre-state variables |
MvSet |
SeqMvRelation.getPreVariablesCube()
return cube of pre-state variables |
MvSet |
MvSetMvRelation.getPreVariablesCube()
return cube of pre-state variables |
MvSet |
AbstractMvSet.impl(MvSet v)
|
MvSet |
MvSet.impl(MvSet v)
|
MvSet |
AbstractMvSet.infoAnd(MvSet v)
|
MvSet |
MvSet.infoAnd(MvSet v)
|
MvSet |
JCUDDMvSetFactory.infoBot()
|
MvSet |
MvSetFactory.infoBot()
|
MvSet |
JCUDDBelnapMvSetFactory.infoBot()
|
MvSet |
MDDMvSetFactory.infoBot()
|
MvSet |
AbstractMvSetFactory.infoBot()
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.infoNot()
|
MvSet |
AbstractMvSet.infoNot()
|
MvSet |
MvSet.infoNot()
|
MvSet |
AbstractMvSet.infoOr(MvSet v)
|
MvSet |
MvSet.infoOr(MvSet v)
|
MvSet |
JCUDDMvSetFactory.infoTop()
|
MvSet |
MvSetFactory.infoTop()
|
MvSet |
JCUDDBelnapMvSetFactory.infoTop()
|
MvSet |
MDDMvSetFactory.infoTop()
|
MvSet |
AbstractMvSetFactory.infoTop()
|
MvSet |
AbstractMvSet.leq(MvSet v)
|
MvSet |
MvSet.leq(MvSet v)
|
MvSet |
AbstractMvSet.not()
|
MvSet |
MvSet.not()
|
MvSet |
AbstractMvSet.or(MvSet v)
|
MvSet |
MvSet.or(MvSet v)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
MDDMvSetFactory.MDDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
JADDMvSetFactory.JADDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
MvSet.ptwiseCompare(int op,
MvSet g)
Ptwise compare: <=, >=, =. |
MvSet |
CUADDMvSetFactory.CUADDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
MDDMvSetFactory.MDDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
JADDMvSetFactory.JADDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
MvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
CUADDMvSetFactory.CUADDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.ptwiseNeg()
Creates a ptwise negation h (x) = \neg f (x) |
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseNeg()
Creates a ptwise negation h (x) = \neg f (x) |
MvSet |
MDDMvSetFactory.MDDMvSet.ptwiseNeg()
Creates a ptwise negation h (x) = \neg f (x) |
MvSet |
JADDMvSetFactory.JADDMvSet.ptwiseNeg()
Creates a ptwise negation h (x) = \neg f (x) |
MvSet |
MvSet.ptwiseNeg()
Creates a ptwise negation h (x) = \neg f (x) |
MvSet |
CUADDMvSetFactory.CUADDMvSet.ptwiseNeg()
Creates a ptwise negation h (x) = \neg f (x) |
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.renameArgs(int[] newArgs)
Renames the arguments. |
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.renameArgs(int[] newArgs)
Renames the arguments. |
MvSet |
MDDMvSetFactory.MDDMvSet.renameArgs(int[] newArgs)
Renames the arguments. |
MvSet |
JADDMvSetFactory.JADDMvSet.renameArgs(int[] newArgs)
Renames the arguments. |
MvSet |
MvSet.renameArgs(int[] newArgs)
Renames the arguments. |
MvSet |
CUADDMvSetFactory.CUADDMvSet.renameArgs(int[] newArgs)
Renames the arguments. |
MvSet |
MvRelation.toMvSet()
Converts this transformer to an MvSet over pre- and
post-variables, if possible. |
MvSet |
SeqMvRelation.toMvSet()
|
MvSet |
MvSetMvRelation.toMvSet()
|
MvSet |
JCUDDMvSetFactory.top()
|
MvSet |
MvSetFactory.top()
|
MvSet |
JCUDDBelnapMvSetFactory.top()
|
MvSet |
MDDMvSetFactory.top()
|
MvSet |
JADDMvSetFactory.top()
|
MvSet |
CUADDMvSetFactory.top()
|
MvSet |
JCUDDMvSetFactory.var(int argIdx,
AlgebraValue argVal,
AlgebraValue value)
|
MvSet |
MvSetFactory.var(int arg,
AlgebraValue argVal,
AlgebraValue value)
Builds an mvset corresponding to (arg = argVal) /\ value |
MvSet |
JCUDDBelnapMvSetFactory.var(int argIdx,
AlgebraValue argVal,
AlgebraValue value)
|
MvSet |
MDDMvSetFactory.var(int argIdx,
AlgebraValue argVal,
AlgebraValue value)
|
MvSet |
JADDMvSetFactory.var(int argIdx,
AlgebraValue argVal,
AlgebraValue value)
|
MvSet |
CUADDMvSetFactory.var(int argIdx,
AlgebraValue argVal,
AlgebraValue value)
|
Methods in edu.toronto.cs.mvset with parameters of type MvSet | |
---|---|
MvSet |
AbstractMvSet.and(MvSet v)
Utility functions |
MvSet |
MvSet.and(MvSet v)
Utility functions |
MvSet |
MvRelation.bwdImage(MvSet v)
Computes the backward image (a.k.a, pre, EX) of v . |
MvSet |
SeqMvRelation.bwdImage(MvSet v)
|
MvSet |
MvSetMvRelation.bwdImage(MvSet v)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.cofactor(MvSet cube)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.cofactor(MvSet cube)
|
MvSet |
MDDMvSetFactory.MDDMvSet.cofactor(MvSet point)
|
MvSet |
AbstractMvSet.cofactor(MvSet point)
|
MvSet |
MvSet.cofactor(MvSet point)
|
MvSet |
JCUDDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
MvSetFactory.createCase(int argIdx,
MvSet[] children)
createCase creates a case relative to argIdx
this is somewhat simillar to Ite (if-then-else) in CUDD
but extended to more than two children. |
MvSet |
JCUDDBelnapMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
MDDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
JADDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
CUADDMvSetFactory.createCase(int argIdx,
MvSet[] children)
|
MvSet |
JCUDDMvSetFactory.createIte(int argIdx,
MvSet child0,
MvSet child1)
|
MvSet |
JCUDDBelnapMvSetFactory.createIte(int argIdx,
MvSet child0,
MvSet child1)
|
MvSet |
CUADDMvSetFactory.createIte(int argIdx,
MvSet child0,
MvSet child1)
|
MvSet |
MvRelation.dualBwdImage(MvSet v)
Computes the logical dual of backward image (a.k.a. |
MvSet |
SeqMvRelation.dualBwdImage(MvSet v)
|
MvSet |
MvSetMvRelation.dualBwdImage(MvSet v)
|
MvSet |
AbstractMvSet.eq(MvSet v)
|
MvSet |
MvSet.eq(MvSet v)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.existAbstract(MvSet _cube)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.existAbstract(MvSet _cube)
|
MvSet |
MDDMvSetFactory.MDDMvSet.existAbstract(MvSet _cube)
|
MvSet |
JADDMvSetFactory.JADDMvSet.existAbstract(MvSet _cube)
|
MvSet |
MvSet.existAbstract(MvSet cube)
|
MvSet |
CUADDMvSetFactory.CUADDMvSet.existAbstract(MvSet _cube)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.forallAbstract(MvSet _cube)
|
MvSet |
MDDMvSetFactory.MDDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
JADDMvSetFactory.JADDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
MvSet.forallAbstract(MvSet cube)
|
MvSet |
CUADDMvSetFactory.CUADDMvSet.forallAbstract(MvSet _cube)
|
MvSet |
MvRelation.fwdImage(MvSet v)
Computes forward image (post) of v |
MvSet |
SeqMvRelation.fwdImage(MvSet v)
|
MvSet |
MvSetMvRelation.fwdImage(MvSet v)
|
MvSet |
AbstractMvSet.geq(MvSet v)
|
MvSet |
MvSet.geq(MvSet v)
|
MvSet |
AbstractMvSet.impl(MvSet v)
|
MvSet |
MvSet.impl(MvSet v)
|
MvSet |
AbstractMvSet.infoAnd(MvSet v)
|
MvSet |
MvSet.infoAnd(MvSet v)
|
MvSet |
AbstractMvSet.infoOr(MvSet v)
|
MvSet |
MvSet.infoOr(MvSet v)
|
MvSet |
AbstractMvSet.leq(MvSet v)
|
MvSet |
MvSet.leq(MvSet v)
|
java.util.Iterator |
JCUDDMvSetFactory.JCUDDMvSet.mintermIterator(MvSet vars,
AlgebraValue val)
|
java.util.Iterator |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.mintermIterator(MvSet vars,
AlgebraValue val)
|
java.util.Iterator |
MDDMvSetFactory.MDDMvSet.mintermIterator(MvSet _vars,
AlgebraValue val)
|
java.util.Iterator |
AbstractMvSet.mintermIterator(MvSet vars,
AlgebraValue v)
|
java.util.Iterator |
MvSet.mintermIterator(MvSet vars,
AlgebraValue val)
|
MvSet |
AbstractMvSet.or(MvSet v)
|
MvSet |
MvSet.or(MvSet v)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
MDDMvSetFactory.MDDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
JADDMvSetFactory.JADDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
MvSet.ptwiseCompare(int op,
MvSet g)
Ptwise compare: <=, >=, =. |
MvSet |
CUADDMvSetFactory.CUADDMvSet.ptwiseCompare(int op,
MvSet g)
|
MvSet |
JCUDDMvSetFactory.JCUDDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
MDDMvSetFactory.MDDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
JADDMvSetFactory.JADDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
MvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
MvSet |
CUADDMvSetFactory.CUADDMvSet.ptwiseCompose(int op,
MvSet g)
Creates a pointwise composition op is an operator: L x L -> L f is the current mv-set result h (x) = f (x) op g (x) |
void |
MvRelation.setTrans(MvSet v)
Sets the transition part of the relation from an mvset over pre- and post- variables |
void |
SeqMvRelation.setTrans(MvSet v)
|
void |
MvSetMvRelation.setTrans(MvSet v)
|
MvRelation |
JCUDDMvSetFactory.JCUDDMvSet.toMvRelation(MvSet invariant,
MvSet preVariablesCube,
MvSet postVariablesCube,
int[] preToPostMap,
int[] postToPreMap)
|
MvRelation |
JCUDDBelnapMvSetFactory.JCUDDBelnapMvSet.toMvRelation(MvSet invariant,
MvSet preVariablesCube,
MvSet postVariablesCube,
int[] preToPostMap,
int[] postToPreMap)
|
MvRelation |
AbstractMvSet.toMvRelation(MvSet invar,
MvSet preVarCube,
MvSet postVarCube,
int[] preToPostMap,
int[] postToPreMap)
|
MvRelation |
MvSet.toMvRelation(MvSet invar,
MvSet preVarCube,
MvSet postVarCube,
int[] preToPostMap,
int[] postToPreMap)
|
MvRelation |
AbstractMvSet.toMvRelation(MvSet invar,
MvSet invarPost,
MvSet preVarCube,
MvSet postVarCube,
int[] preToPostMap,
int[] postToPreMap)
|
MvRelation |
MvSet.toMvRelation(MvSet invar,
MvSet invarPost,
MvSet preVarCube,
MvSet postVarCube,
int[] preToPostMap,
int[] postToPreMap)
|
Constructors in edu.toronto.cs.mvset with parameters of type MvSet | |
---|---|
MvSetMvRelation(MvSet _reln,
MvSet _preVariablesCube,
MvSet _postVariablesCube,
int[] _preToPostMap,
int[] _postToPreMap)
|
|
MvSetMvRelation(MvSet _reln,
MvSet _invariant,
MvSet _preVariablesCube,
MvSet _postVariablesCube,
int[] _preToPostMap,
int[] _postToPreMap)
Creates a new MvSetMvRelation instance. |
|
MvSetMvRelation(MvSet _reln,
MvSet _invariant,
MvSet _invariantPost,
MvSet _preVariablesCube,
MvSet _postVariablesCube,
int[] _preToPostMap,
int[] _postToPreMap)
Creates a new MvSetMvRelation instance. |
Uses of MvSet in edu.toronto.cs.proof |
---|
Methods in edu.toronto.cs.proof that return MvSet | |
---|---|
MvSet |
ProofStep.getState()
|
Methods in edu.toronto.cs.proof with parameters of type MvSet | |
---|---|
static ProofStep |
ProofStepFactory.makeProofStep(AlgebraValue _v,
MvSet _state,
CTLNode _consequent)
|
static java.lang.String |
ProofStepFactory.makeStateName(MvSet state)
|
Constructors in edu.toronto.cs.proof with parameters of type MvSet | |
---|---|
ConjProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
DisjProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String stateName,
CTLNode _consequent,
DisjProofStrategy _strategy)
|
|
EGProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
EUiProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent,
int _bound)
|
|
EUProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
EXProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
NegProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
ProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
|
PropProofStep(AlgebraValue _v,
MvSet _state,
java.lang.String _stateName,
CTLNode _consequent)
|
Uses of MvSet in edu.toronto.cs.proof2 |
---|
Methods in edu.toronto.cs.proof2 that return MvSet | |
---|---|
protected abstract MvSet |
CTLProver.PreferAvoidEXProofRule.getPreferred(MvSet allSucc)
|
MvSet |
Formula.getState()
|
Methods in edu.toronto.cs.proof2 with parameters of type MvSet | |
---|---|
static void |
CTLProver.dumpMvSet(MvSet mvSet,
AlgebraValue x)
|
static Formula |
Formula.duplicate(Formula f,
CTLNode ctl,
AlgebraValue val,
MvSet state)
|
protected abstract MvSet |
CTLProver.PreferAvoidEXProofRule.getPreferred(MvSet allSucc)
|
void |
CTLProver.BaseEXProofRule.getSuccessorMap(MvSet state,
java.lang.String name,
CTLNode conseq)
|
Constructors in edu.toronto.cs.proof2 with parameters of type MvSet | |
---|---|
AboveFormula(CTLNode _ctl,
AlgebraValue _val,
MvSet _state)
|
|
BelowFormula(CTLNode _ctl,
AlgebraValue _val,
MvSet _state)
|
|
ComparisonFormula(CTLNode _ctl,
AlgebraValue _val,
MvSet _state)
|
|
EqualFormula(CTLNode _ctl,
AlgebraValue _val,
MvSet _state)
|
|
Formula(CTLNode _ctl,
AlgebraValue _val,
MvSet _state)
|
|
VisitedEXProofRule(MvSetModelChecker mc,
MvSet _visited)
|
Uses of MvSet in edu.toronto.cs.simulator |
---|
Methods in edu.toronto.cs.simulator that return MvSet | |
---|---|
MvSet |
XCStateInfo.getVariables()
Retrieves the state variables. |
Constructors in edu.toronto.cs.simulator with parameters of type MvSet | |
---|---|
XCStateInfo(MvSet vars)
Constructs the state info from the MvSet identifying the state. |
|
XCStateInfo(java.lang.String l,
MvSet vars)
Constructs the state info from the MvSet identifying the state and a label. |
Uses of MvSet in edu.toronto.cs.smv |
---|
Methods in edu.toronto.cs.smv that return MvSet | |
---|---|
MvSet |
VariableTable.EnumeratedVariable.__eq(VariableTable.EnumeratedVariable v)
|
MvSet |
SMVModule.AlgebraDefine.and(MvSet v)
|
MvSet |
SMVModule.AlgebraDefine.and(SMVModule.AlgebraVariable v)
|
MvSet |
SMVModule.IntDefine.buildMvSet()
|
MvSet |
SMVModule.IntVariable.buildMvSet()
|
MvSet |
VariableTable.CaseTranslator.compute()
|
MvSet |
SMVModule.CaseStatement.compute()
|
MvSet |
SMVModule.BoolCaseStatement.compute()
|
MvSet |
Lift.computeCall(Lift.Button[] buttons)
|
MvSet |
LiftAbstract.computeCall(LiftAbstract.Button[] buttons)
|
MvSet |
MainLift.computeCall(MainLift.Button[] buttons)
|
MvSet |
Lift.computeInit()
|
MvSet |
Lift.Button.computeInit()
|
MvSet |
Lift.LiftCabin.computeInit()
|
abstract MvSet |
SMVModule.computeInit()
|
MvSet |
AxelEx1b.computeInit()
|
MvSet |
MainLift.computeInit()
|
MvSet |
MainLift.Button.computeInit()
|
MvSet |
MainLift.Lift.computeInit()
|
MvSet |
FairTester.computeInit()
|
MvSet |
LiftAbstract.computeInit()
|
MvSet |
LiftAbstract.Button.computeInit()
|
MvSet |
LiftAbstract.LiftCabin.computeInit()
|
MvSet |
OneBtn.computeInit()
|
MvSet |
ConcurExample.computeInit()
|
MvSet |
MyGame.computeInit()
|
MvSet |
AxelEx2.computeInit()
|
MvSet |
Game.computeInit()
|
MvSet |
Helmut.computeInit()
|
MvSet |
Simple.computeInit()
|
MvSet |
AxelEx1a.computeInit()
|
MvSet |
AxelEx4.computeInit()
|
MvSet |
AxelEx1b.computeInitSingleState()
|
MvSet |
AxelEx2.computeInitSingleState()
|
MvSet |
Lift.computeTrans()
|
MvSet |
Lift.Button.computeTrans()
|
MvSet |
Lift.LiftCabin.computeTrans()
|
abstract MvSet |
SMVModule.computeTrans()
|
MvSet |
AxelEx1b.computeTrans()
|
MvSet |
MainLift.computeTrans()
|
MvSet |
MainLift.Button.computeTrans()
|
MvSet |
MainLift.Lift.computeTrans()
|
MvSet |
FairTester.computeTrans()
|
MvSet |
LiftAbstract.computeTrans()
|
MvSet |
LiftAbstract.Button.computeTrans()
|
MvSet |
LiftAbstract.LiftCabin.computeTrans()
|
MvSet |
OneBtn.computeTrans()
|
MvSet |
ConcurExample.computeTrans()
|
MvSet |
MyGame.computeTrans()
|
MvSet |
AxelEx2.computeTrans()
|
MvSet |
Game.computeTrans()
|
MvSet |
Helmut.computeTrans()
|
MvSet |
Simple.computeTrans()
|
MvSet |
AxelEx1a.computeTrans()
|
MvSet |
AxelEx4.computeTrans()
|
MvSet |
SMVModule.IntDefine.eq(int num)
|
abstract MvSet |
VariableTable.Variable.eq(MvSet v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(MvSet v)
|
MvSet |
VariableTable.StateVariable.eq(MvSet v)
|
MvSet |
SMVModule.Variable.eq(MvSet v)
|
MvSet |
SMVModule.Variable.eq(SMVModule.Variable v)
|
abstract MvSet |
VariableTable.Variable.eq(java.lang.String v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(java.lang.String v)
|
MvSet |
VariableTable.StateVariable.eq(java.lang.String v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(VariableTable.EnumeratedVariable v)
|
MvSet |
VariableTable.StateVariable.eq(VariableTable.StateVariable v)
|
abstract MvSet |
VariableTable.Variable.eq(VariableTable.Variable v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(VariableTable.Variable v)
|
MvSet |
VariableTable.StateVariable.eq(VariableTable.Variable v)
|
abstract MvSet |
VariableTable.Variable.eqNext()
|
MvSet |
VariableTable.EnumeratedVariable.eqNext()
|
MvSet |
VariableTable.StateVariable.eqNext()
|
MvSet |
SMVModule.IntDefine.geq(int num)
|
MvSet |
VariableTable.StateVariable.getMvSet()
|
MvSet |
SMVModule.IntDefine.gt(int num)
|
MvSet |
SMVModule.intConstant(int i)
|
MvSet |
SMVModule.IntDefine.leq(int num)
|
MvSet |
SMVModule.IntDefine.lt(int num)
|
MvSet |
SMVModule.IntDefine.minus(int num)
|
MvSet |
SMVModule.Variable.mvSet()
|
MvSet |
SMVModule.AlgebraDefine.not()
|
MvSet |
SMVModule.AlgebraDefine.or(MvSet v)
|
MvSet |
SMVModule.AlgebraDefine.or(SMVModule.AlgebraVariable v)
|
MvSet |
SMVModule.IntDefine.plus(int num)
|
Methods in edu.toronto.cs.smv with parameters of type MvSet | |
---|---|
VariableTable.CaseTranslator |
VariableTable.CaseTranslator.addCase(MvSet cond,
MvSet stmt)
|
SMVModule.CaseStatement |
SMVModule.CaseStatement.addCase(MvSet cond,
MvSet stmt)
|
SMVModule.BoolCaseStatement |
SMVModule.BoolCaseStatement.addCase(MvSet cond,
MvSet stmt)
|
SMVModule.CaseStatement |
SMVModule.CaseStatement.addCase(SMVModule.Variable v,
MvSet stmt)
|
VariableTable.CaseTranslator |
VariableTable.CaseTranslator.addDefault(MvSet stmt)
|
SMVModule.CaseStatement |
SMVModule.CaseStatement.addDefault(MvSet stmt)
|
SMVModule.BoolCaseStatement |
SMVModule.BoolCaseStatement.addDefault(MvSet stmt)
|
MvSet |
SMVModule.AlgebraDefine.and(MvSet v)
|
VariableTable.DefineVariable |
VariableTable.declareDefine(java.lang.String name,
MvSet value)
|
abstract MvSet |
VariableTable.Variable.eq(MvSet v)
|
MvSet |
VariableTable.EnumeratedVariable.eq(MvSet v)
|
MvSet |
VariableTable.StateVariable.eq(MvSet v)
|
MvSet |
SMVModule.Variable.eq(MvSet v)
|
MvSet |
SMVModule.AlgebraDefine.or(MvSet v)
|
void |
SMVModule.Variable.setMvSet(MvSet v)
|
void |
Lift.Button.setReset(MvSet v)
|
void |
MainLift.Button.setReset(MvSet v)
|
void |
LiftAbstract.Button.setReset(MvSet v)
|
CTLNode[] |
SMVModule.SMVStatePresenter.toCTL(MvSet cube)
|
Constructors in edu.toronto.cs.smv with parameters of type MvSet | |
---|---|
SMVModule.BoolCaseStatement(MvSet _mvBot)
|
|
VariableTable.DefineVariable(java.lang.String name,
MvSet value)
|
|
VariableTable.StateVariable(java.lang.String name,
MvSet _mvSet)
|
Uses of MvSet in edu.toronto.cs.smv.parser |
---|
Methods in edu.toronto.cs.smv.parser that return MvSet | |
---|---|
MvSet |
DDBuilder.aset(antlr.collections.AST _t)
|
MvSet |
DDBuilder.astmt(antlr.collections.AST _t)
|
MvSet |
FullDDBuilder.expression(antlr.collections.AST _t,
VariableTable.Variable var)
|
MvSet |
DDBuilder.getInit()
|
MvSet |
DDBuilder.getTrans()
|
MvSet |
DDBuilder.init(antlr.collections.AST _t)
|
MvSet |
DDBuilder.kase(antlr.collections.AST _t)
|
MvSet |
DDBuilder.next(antlr.collections.AST _t)
|
MvSet |
DDBuilder.predicate(antlr.collections.AST _t)
|
Uses of MvSet in edu.toronto.cs.tlq |
---|
Methods in edu.toronto.cs.tlq that return MvSet | |
---|---|
MvSet |
MvSetCrossProductAlgebra.CrossProductValue.getValue(int i)
|
Methods in edu.toronto.cs.tlq with parameters of type MvSet | |
---|---|
MvSetUpsetAlgebra.MvSetUpsetValue |
MvSetUpsetAlgebra.getJoinIrreducible(int i,
MvSet mvSet)
Convinience method to produce an join irreducible element of this algebra without creating a cross-product element first. |
CTLNode |
MvSetPlaceholderReWriter.getOneSolution(MvSet v,
StatePresenter presenter,
boolean negated)
|
MvSetCrossProductAlgebra.CrossProductValue |
MvSetCrossProductAlgebra.newValue(int idx,
MvSet v)
|
Uses of MvSet in edu.toronto.cs.xkripke |
---|
Methods in edu.toronto.cs.xkripke that return MvSet | |
---|---|
static MvSet |
XKripkeMvSetBuilder.buildMvSet(MvSetFactory mvSetFactory,
XKripke kripke)
mvSetFactory -- needed to create MvSets kripke -- the XKripke model to convert propOrder -- interface to order the atomic props |
static MvSet |
XKripkeMvSetBuilder.buildTransition(MvSetFactory mvSetFactory,
IAlgebra algebra,
XKripke.XKripkeTransition trans,
VariableTable vt)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |