Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234567]

Pfrodo2
Palgorithms	Package containing various algorithms
Padopt	Classes implementing the ADOPT algorithm
Ptest	Unit tests for the ADOPT algorithm
CADOPTagentTest	JUnit test for ADOPTagent
CAllTestsADOPT	Test suite for all ADOPT tests
CtestADOPT	This class is used to test the workings of the ADOPT listener
CtestPreprocessing	JUnit tests for the Preprocessing module
CreceiveLowerBounds
CforwardHeuristicsMessage	This listener simply forwards all Heuristics messages to the central stats reporter
CADOPT	This class implements the ADOPT algorithm as described in:
CVersion	The different versions of adopt handle some things differently
COriginal	The original adopt version
CVariableInfo	Helper class that contains all the info belonging to a specific variable
CADOPTsolver	A DCOP solver using ADOPT
CBoundsMsg	A message containing the heuristics for the lower bound
CCOSTmsg	The message used to send a VALUE message to a variable's pseudochildren in ADOPT
CENDmsg	The message used to send a terminate message to a variable's children
CHeuristicMsg	Message used to send the minimal utility of the agents local sub problem
CPreprocessing
CPreprocessingHeuristic	This interface is used to implement the different heuristics for obtaining lower bounds
CVariableInfo	Container for information belonging to a specific variable
CSimpleHeuristic	This simple heuristic sets all lower bounds to zero, and should be used when running the original adopt
CDP0	Implementation of the DP0 heuristic
CVariableInfo	A container for variable dependent information
CDP1	Implementation of the DP1 heuristic
CVariableInfo	Container for information belonging to a specific variable
CDP2	Implementation of the DP2 heuristic
CVariableInfo	Convenience class that contains information on a specific variable
CVALUEmsg	The message used to send a VALUE message to a variable's pseudochildren
Pafb
Ptest	Tests for the SynchBB algorithm
CAFBagentTest	JUnit tests for AFB
CAllTestsAFB	JUnit test suite for all the tests in frodo2.algorithms.afb.test
CAFB	The AFB algorithm by Gershman, Meisels, and Zivan (JAIR'09)
CConvergenceMessage	A message reporting the convergence for a given component
CClusterInfo	Information about a cluster of variables owned by this agent
CComponentInfo	The information about a particular component of the constraint graph
CAFBBaseMsg	All AFB messages containing a CPA subclass this class
CAFBsolver	A DCOP solver using AFB
CCPAmsg	The message containing the current partial assignment in AFB
CFbCpaMsg	The FB_CPA message in AFB
CFbEstimateMsg	The FB_ESTIMATE message in AFB
CPA	Class holding a partial assignment for AFB
CSolutionMsg	A message containing the optimal solution found so far
CTimestamp	Timestamp mechanism for AFB
Pasodpop	Classes implementing the ASO-DPOP algorithm
PgoodsTree
PinnerNodeTree
CInnerNodeTree	This class is designed to store GOODs received by a node from its children, and is used in the ASODPOP algorithm
CLeafNode	The leaf node of a tree
PinnerNodeTreeBinaryDomains
CInnerNodeTree	This class is designed to store GOODs received by a node from its children, and is used in the ASODPOP algorithm
CLeafNode	The leaf node of a tree
PleafNodeTree
CLeafNodeTree
Ptests	All tests for the ASO-DPOP algorithm
CAllTestsASODPOP	Tests for the ASODPOP algorithm
CASODPOPagentTest	JUnit test of the ASODPOP agent
CASODPOPBinaryAgentTest	JUnit test of the ASODPOP agent
CASODPOPBinaryTest	JUnit test for the class ASODPOP
CASODPOPTest	JUnit test for the class ASODPOP
CACKmsg	This message is used to ask a child for new information
CASODPOP	This class implements both the UTIL propagation phase and the VALUE propagation of the ASODPOP algorithm
CVariableInfo	A convenience class that contains the following information for a variable
CdetermineAssignment	In the future we might want to experiment with different ways of determining a variables assignment
CDetermineAssignmentMax	This class should be used when only a single hierarchy is used
CAssignmentMessage	Assignment message used to reported the variables assignment and some statistics about the run
CASODPOPBinaryDomains	This class implements both the UTIL propagation phase and the VALUE propagation of the ASODPOP algorithm
CVariableInfo	A convenience class that contains the following information for a variable
CdetermineAssignment	In the future we might want to experiment with different ways of determining a variables assignment
CDetermineAssignmentMax	This class should be used when only a single hierarchy is used
CASODPOPBinarysolver	This is a solver that reads in the problem, creates the agents, runs the problem and then collects the statistics
CASODPOPsolution	An optimal solution to the problem
CASODPOPsolver	This is a solver that reads in the problem, creates the agents, runs the problem and then collects the statistics
CGood	Class that represents a good being send fom child to parent It contains
CUTILdomMsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILmsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILvarsDomsMsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILvarsMsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILvarsMsgWithDom	This message contains the util information a child reports to its parent when responding to an ASK message
CVALUEmsgChild	A VALUE message, which contains the value assignment of a variable
CVALUEmsgPseudo	A VALUE message, which contains the value assignment of a variable
Pdpop	Classes implementing the DPOP algorithm and its variants
Pcount	A utility to count the number of optimal solutions in a DCOP
Ptest
CTestCountSolutions
CCountSolutionsUTIL	Classical UTIL propagation protocol
CSolutionMessage	A message holding the optimal assignments to a variable, conditioned on the assignments to the variables in its separator
CSeparatorMessage	A message holding the separator of a given child variable
COptUtilMessage	Message sent by roots containing the optimal utility value of their DFS tree
CStatsMessage	Message containing statistics
CVariableInfo	A convenience class used to store information about a variable
CCountSolutionsVALUE	VALUE propagation protocol
CSolutionSizeMessage
CSolutionCounter	Counts the number of optimal solutions in a DCOP
CVALUEmsg	VALUE message
Pmemory	MB-DPOP's memory-bounded version of DPOP
Ptests	Tests for MB-DPOP
CMB_DPOPagentTest	An overall unit test for the MB-DPOP algorithm
CContextMsg	A CONTEXT message sent by cluster nodes in MB-DPOP
CLabelingPhase	MB-DPOP's labeling phase that identifies cluster roots (CRs) and cycle-cut (CC) nodes
CVarInfo	A class containing all the useful information about one of the agent's variables
CStatsMsg	A message containing stats about a variable
COutputMsg	The output message for a given variable
CLabelMsg	The class of the LABEL messages sent by MB-DPOP's labeling phase
CMemoryBoundedUTIL	MB-DPOP's memory-bounded UTIL propagation phase
CVarInfo	The information about a given variable
Pparam	Classes implementing the Param-DPOP algorithm, able to solve DCOP involving free parameters
Ptest	Tests for Param-DPOP
CAllTestsParamDPOP	JUnit test suite for all the tests in frodo2.algorithms.dpop.param.test
CParamDPOPtest	JUnit test for Param-DPOP
CParamUTILtest	JUnit test for the class ParamUTIL
CListener	The listener that checks the messages sent by the ParamUTIL listeners
CParamVALUEtest	JUnit test for the class ParamVALUE
CListener	The listener that checks the messages sent by the ParamUTIL and ParamVALUE listeners
CParamDPOPsolver	A DCOP solver using Param-DPOP
CParamSolution	An optimal solution to the problem
CParamUTIL	A UTIL propagation protocol that supports parameters (i.e
COptUtilMessage	Message sent by roots containing the optimal utility value of their DFS tree, conditioned on the values of the parameters (if any)
CParamVALUE	VALUE propagation protocol
CAssignmentMessage	A message holding the optimal assignment to some variables, conditioned on the values of the parameters (if any)
CVALUEmsg	VALUE message
Pprivacy	Classes implementing the P-DPOP and P2-DPOP algorithms that preserve privacy
Ptest	Tests for P-DPOP and P2-DPOP
CAllTestsP_DPOP	JUnit test suite for all the tests in frodo2.algorithms.dpop.privacy.test
CFakeCryptoScheme	A fake CryptoScheme used to test and debug P2-DPOP
CFakePublicKeyShare	A share of the (unused) public key
CFakeEncryptedInteger	A wrapper around a BigInteger so that it implements AddableLimited
CFakeCryptoSchemeTest	Junit test to test the FakeCryptoScheme
CP2_DPOPagentTest	JUnit test for P_DPOP agent
CP3halves_DPOPagentTest	A JUnit test for the P3/2-DPOP agent
CP_DPOPagentTest	JUnit test for P_DPOP agent
CSecureCircularRoutingTest	Test case for the module SecureCircularRouting
CTestMessage	A message holding the sender variable and the number of variables visited so far
CForwarder	A test listener that asks the SecureCircularRouting message, for each variable, to forward a message forward all the way until it comes back, and same backwards
CSecureRerootingTest	JUnit test for the SecureRerooting module
CVariableObfuscationTest	Unit tests for VariableObfuscation
CCodeNameMsg	Message sent by VariableObfuscation to transmit codeNames
CCollaborativeDecryption	P2-DPOP's collaborative decryption module
CVariableInfo	Convent class to store information about a variable
CStatRequestOutput	Message sent to stat gatherer with all decryption requests for an agent
CCryptoSchemeMsg	Message used to transfer the cryptoScheme to others modules of this agent
CVectorOutput	Vector decryption Output Message
CDecryptionOutput	Decryption Output Message
CDecryptRequest	Decryption Request Message
CDecryptVectorRequest	Vector decryption request
CDeliveryMsg	A wrapper message containing a message to be delivered to a given variable by SecureCircularRouting
CDoneMsg	Message token used to tell to the root that the dfs can be rerooted
CEncrUTIL	Encrypted UTIL msg
CEncryptedUTIL	P2-DPOP's UTIL propagation module, using partially homomorphic encryption on utilities and a linear order on variables
CVariableInfo	A convenience class used to store information about a variable
CKeyShareMsg	Message used to share the public key shares of the CryptoScheme
CLeafMsg	A token sent by the root in P2-DPOP to tell the last variable in the linear ordering to start UTIL propagation
CObfsVALUEmsg	VALUE message sent and decoded by VariableObfuscation
CObsfUTILmsg	UTIL Message sent and decoded by VariableObfuscation
COptUtilMsg	A message containing the optimal utility found for a given component
CP2_DPOPsolver	A DCOP solver using P2-DPOP
CP3halves_DPOPsolver	A solver for P-DPOP with rerooting
CP_DPOPsolver	A DCOP solver using P-DPOP
CRerootingMsg	Message used to send a reroot request
CRerootRequester	A module that waits for the root variable to compute its optimal value, and then calls for a rerooting
CRootValueMsg	The class of statistics messages containing the optimal assignment to a variable
CRoutingMsg	A wrapper message around a payload message that must be routed through the DFS
CSecureCircularRouting	Enables sending a message to the previous/next variable in a circular ordering of variables based on a DFS
CSecureRerooting	P2-DPOP's variable re-ordering algorithm
CVariableInfo	Convenient class to store information about a variable of this agent
CSecureRootingMsg	Message used to tell a variable that it is the new root of its component
CStopMsg	A message stating that the problem is infeasible
CToLastLeafMsg	A wrapper message containing a payload message that must be forwarded to the last leaf in the sub-tree rooted at the destination variable
CVarCodenameMsg	Message sent by EncryptedUTIL to transmit codeNames
CVariableObfuscation	Module that intercepts messages during UTIL and VALUE propagation and obfuscates the variable names, variable domains, and utility values
CVectorMsg	Message that contains a vector of elements E and a counter
Prestart	Contains classes implementing the S-DPOP algorithm with warm restarts
Ptest	Tests for the S-DPOP algorithm with warm restarts
CAllTestsS_DPOP	JUnit test suite for all the tests in frodo2.algorithms.dpop.restart.test
CTestSDPOP	JUnit tests for Util reuse in S-DPOP
CToken	Message sent and received by UTILreuse module during warm restarts
CUTILreuse	UTIL message storage for warm restarts of S-DPOP
Pstochastic	Classes implementing the E[DPOP] family of algorithms for Stochastic DCOP
Probust	StochDCOP algorithms that maximize worst-case rather than expected utility
Ptest	Unit tests for Robust-E[DPOP]
CRobust_E_DPOPagentTest	Unit tests for Robust-E[DPOP]
CWorstCaseUTIL	A UTIL propagation phase that maximizes worst-case utility with respect to the random variables
Ptest	Tests for the family of E[DPOP] algorithms
CAllTestsStochDPOP	JUnit test suite for all the tests in frodo2.algorithms.dpop.stochastic.test
CE_DPOPagentTest	A JUnit test case for E[DPOP]
CExpectedUTILtest	JUnit tests for ExpectedUTIL
CListener	The listener that checks the messages sent by the ExpectedUTIL listeners
CLowestCommonAncestorsTest	A JUnit test case for LowestCommonAncestors
CSamplingPhaseTest	JUnit tests for SamplingPhase
CComplete_E_DPOPsolver	The solver for Comp-E[DPOP]
CCompleteUTIL	Implements an adaptation of the QDisCSP approach by Yokoo (DCR'09)
CRandVarsProjMsg	Message telling what random variables should be projected out at given decision variable
CE_DPOPsolver	A StochDCOP solver using E[DPOP]
CStochSolution	A solution to a StochDCOP, including the expected and worst-case utilities
CExpectedUTIL	E[DPOP]'s UTIL propagation phase
CMethod	The method to use to choose the optimal value for a variable
CLCAmsg1	A phase 1 message containing flags
CLCAmsg2	A message with flags, used both for phase 2 and as an output message of LowestCommonAncestors
CLowestCommonAncestors	An algorithm to compute multiple Lowest Common Ancestors
CNodeInfo	Information about a node in the DFS
CSamplesMsg1	Phase 1 LCA message containing proposed samples for the random variables
CSamplesMsg2	Message used by the SamplingPhase module in phase 2, to which samples have been added
CSamplingPhase	Algorithm that generates samples for the random variables in the problem
CRandVarsProjMsg	Message telling what random variables should be projected out at given decision variable
CWhereToProject	Where the random variables should be projected out
CAtLeaves	The version of the SamplingPhase that samples at the leaves
CAtLCAs	The version of the SamplingPhase that samples at the lcas
CAtRoots	A version of the SamplingPhase in which the sampling for all random variables is performed at the roots
Ptest	Tests for the classical DPOP algorithm
CAllTestsDPOP	JUnit test suite for all the tests in frodo2.algorithms.dpop.test
CDPOPagentTest	JUnit test for DPOPagent
CUTILpropagationTest	JUnit test for the class UTILpropagation
CListener	The listener that checks the messages sent by the UTILpropagation listeners
CVALUEpropagationTest	JUnit test for the class VALUEpropagation
CListener	The listener that checks the messages sent by the UTILpropagation and VALUEpropagation listeners
CDPOPsolver	A DCOP solver using DPOP
CUTILmsg	A message containing a utility solution space
CUTILpropagation	Classical UTIL propagation protocol
CSolutionMessage	A message holding the optimal assignments to variables, conditioned on the assignments to the variables in its separator
CSeparatorMessage	A message holding the separator of a given child variable
COptUtilMessage	Message sent by roots containing the optimal utility value of their DFS tree
CStatsMessage	Message containing statistics
CClusterInfo	A convenience class used to store information about a cluster
CVALUEmsg	VALUE message
CVALUEpropagation	VALUE propagation protocol
Pduct
Pbound
CBound
CBoundInvLog
CBoundLog
CBoundLogSize
CBoundSqrt
CBoundSqrtSize
PsamplingMethods
CSamplingB
CSamplingB_Child
CSamplingM
CSamplingM_Child
CSamplingProcedure
CSamplingR
Ptermination
CTerminateBest
CTerminateBest_Child
CTerminateMean
CTerminateRegret
CTerminateRegret_Child
CTerminationCondition
Ptests
CAllTestsDUCT	Tests for the DUCT algorithm
CDUCTagentChildSearchTest	JUnit test for DUCT
CDUCTagentChildTest	JUnit test for DUCT
CDUCTagentPruningSearchTest	JUnit test for DUCT
CDUCTagentPruningTest	JUnit test for DUCT
CDUCTagentTest	JUnit test for DUCT
CNormalizeInfTest
CNormalizeTest
CBOUNDmsg
CBoundStatsMsg	Message that contains the final bound on the solution quality
CCOSTBmsg
CCOSTmsg
CDUCTSolution	Solution class for the family of DUCT algorithms
CDUCTsolver	A DCOP solver using DUCT
CNormalize	This module is a preprocessing module that normalizes all utilities to between 0 and 1
CNormalizeInf	This module is a preprocessing module that normalizes all utilities to between 0 and 1
CNORMmsg
COUTmsg
CSampling
CVariableInfo	Convenience class to hold variable information
CState	Convenience class to store a context
CSamplingChild
CVariableInfo	Convenience class to hold variable information
CSamplingChildSearch
CVariableInfo	Convenience class to hold variable information
CSamplingPruning
CVariableInfo	Convenience class to hold variable information
CSamplingPruningSearch
CVariableInfo	Convenience class to hold variable information
CSearchNode	Convenience class to store information associated to a specific state
CSearchNodeChild	Convenience class to store information associated to a specific state
CSearchNodePruning	Convenience class to store information associated to a specific state
CVALUEmsg
Pheuristics	Classes implementing heuristics that can be used, for instance, to guide the generation of variable orderings
CAgentNameHeuristic	A scoring heuristic that returns the agent's name
CAgentScoringHeuristic	Interface for a heuristic that associates a score to every agent
CLeastConnectedHeuristic	A ScoringHeuristic in which the score for a variable is MINUS its number of neighbors
CMostConnectedHeuristic	A ScoringHeuristic in which the score for a variable is its number of neighbors
CRandScoringHeuristic	A ScoringHeuristic that assigns random scores to variables
CScorePair	A pair of scores, the second being used for tiebreaking
CScoringHeuristic	Interface for a heuristic that associates a score to every variable
CScoringHeuristicWithTiebreaker	A scoring heuristic that supports tiebreaking
CSmallestDomainHeuristic	A scoring heuristic in which the score is MINUS the domain size of the variable
CVarNameHeuristic	A scoring heuristic that returns the variables' names
PlocalSearch
Pdsa	Classes implementing the DSA algorithm
Ptests	Tests for the DSA algorithm
CAllTestsDSA	Tests for the DSA algorithm
CDSAagentTest	JUnit tests for the DSA agent
CTestDSA	JUnit tests for the DSA algorithm
CDSA
CVariableInfo	Container class for information needed for each variable
CDetermineAssignment	Interface used to implement the different decision strategies of DSA
CA
CC
CE
CVarAssignment	Container for a value assignment and its utility
CDSAsolver	This is a solver that reads in the problem, creates the agents, runs the problem and then collects the statistics
CVALUEmsg	Message used to convey the new value of the sender to a neighbouring variable
Pmgm	The MGM algorithm
Pmgm2	The MGM algorithm
Ptests	Tests for MGM2
CMGM2agentTest	JUnit tests for the MGM agent
CACCEPT
CBinaryAssignment
CGO
CIMPROVE
CMGM2	The MGM algorithm
CStateValue	The state of the current variable:
CVariableInfo	Convenience class that contains all necessary information on a single variable
CMGM2solver	This is a solver that reads in the problem, creates the agents, runs the problem and then collects the statistics
CNOGO
COFFER
COFFERold
CREJECT
Ptests	Tests for MGM
CMGMagentTest	JUnit tests for the MGM agent
CIMPROVE
CMGM	The MGM algorithm
CStateValue	The state of the current variable:
CVariableInfo	Convenience class that contains all necessary information on a single variable
CMGMsolver	This is a solver that reads in the problem, creates the agents, runs the problem and then collects the statistics
COK
Pmaxsum
Ptests	Tests for the Max-Sum algorithm
CMaxSumTests	Unit tests for the Max-Sum algorithm
CFunctionMsg	A message sent by a function node
CMaxSum	The Max-Sum Algorithm
CVarInfo	Information about an internal variable
CFunctionInfo	Information about each neighboring function node
CMaxSumSolver	A solver for Max-Sum
CVariableMsg	A message sent by a variable node
Pmpc_discsp	The MPC-Dis(W)CSP algorithms by Marius-Calin Silaghi
Ptests	Tests for the MPC-Dis(W)CSP algorithms
CMPC_DisWCSP4tests	JUnit tests for the MPC-Dis(W)CSP4 algorithms
CEncrSharesMsg	In MPC-DisCSP4, a message containing a vector of ElGamal-encrypted shares
CLUdecomposition	LU decomposition of a matrix
CMatrix	A matrix over a finite field
CMPC_DisCSP4	The MPC-DisCSP4 algorithm for DisCSP with privacy guarantees
CPhase	A phase of the algorithm
CMultiPhase	The phases in a multiplication operation
CMPC_DisWCSP4	The MPC-DisWCSP4 algorithm for DisWCSP with privacy guarantees
CMPC_DisWCSP4solver	A solver for MPC-Dis(W)CSP4
COneShareMsg	In MPC-DisCSP4, a message containing a single share
CPaillierCryptoScheme	The Paillier crypto scheme
CPaillierInteger	A Paillier-encrypted integer
CPaillierPublicKey	A Paillier public key
CSharesMsg	In MPC-DisCSP4, a message containing a vector of shares
CSolShareMsg	A message containing shares of optimal values for some variables
Podpop	Classes implementing the O-DPOP algorithm
PgoodsTree
PInnerNodeTree
CInnerNode	The inner node of a tree
CInnerNodeTree	This class is designed to store GOODs received by a node from its children, and is used in the O-DPOP algorithm
CIntArrayWrapper	The IntArrayWrapper is used as a key for (partial) assignments
CLeafNode	The leaf node of a tree
PInnerNodeTreeBinaryDomains
CInnerNode	The inner node of a tree
CInnerNodeTree	This class is designed to store GOODs received by a node from its children, and is used in the O-DPOP algorithm
PInnerNodeTreeFullDomain
CInnerNode	The inner node of a tree
CInnerNodeTree	This class is designed to store GOODs received by a node from its children, and is used in the O-DPOP algorithm
CIntArrayWrapper	The IntArrayWrapper is used as a key for (partial) assignments
CLeafNode	The leaf node of a tree
CNode	Class for every node in the GoodsTree
PleafNodeTree
CLeafNode
CLeafNodeTree
CNode
CGoodsTree
CAssignment	Convenience class to store assignment/utility combinations in a priority queue
Ptests	Tests for the O-DPOP algorithm
CAllTestsODPOP	Tests for the O-DPOP algorithm
CODPOPagentTest	JUnit test of the ODPOP agent
CODPOPagentTestBinaryDomains	JUnit test of the ODPOP agent
CODPOPagentTestFullDomain	JUnit test of the ODPOP agent
CUTILpropagationTest	Test for the ODPOP UTIL propagation module
CVALUEpropagationTest	Test for the ODPOP VALUE propagation module
CASKmsg	This message is used to ask a child for new information
CAssignment	Class to hold an assignment of variables
CDONEmsg	This message is used to ask a child for new information
CGood	Class that represents a good being send from child to parent It contains
CODPOPsolution	An optimal solution to the problem
CODPOPsolver	A DCOP solver using O-DPOP
CUTILdomMsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILmsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILpropagation	The UTIL propagation phase for O-DPOP
CUTILpropagationBinaryDomains	The UTIL propagation phase for O-DPOP
CUTILpropagationFullDomain	The UTIL propagation phase for O-DPOP
CVariableInfo	Convenience class that contains information for a specific variable
COptUtilMessage	Message sent by roots containing the optimal utility value of their DFS tree
CGoodsTreeMessage	Message used to give the pointer to the goods tree to the VALUE propagation module
CStatsMessage	Message containing statistics
CUTILvarsDomsMsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILvarsMsg	This message contains the util information a child reports to its parent when responding to an ASK message
CUTILvarsMsgWithDom	This message contains the util information a child reports to its parent when responding to an ASK message
CVALUEmsg	VALUE message
CVALUEmsgWithVars	Value message with variables
CVALUEpropagation	O-DPOP's VALUE propagation module
CAssignmentMessage	A message holding an assignment to a variable
Preformulation
CProblemRescaler	A module that rescales the problem
Psynchbb	Classes implementing the SynchBB algorithm
Ptest	Tests for the SynchBB algorithm
CAllTestsSynchBB	JUnit test suite for all the tests in frodo2.algorithms.synchbb.test
CSynchBBagentTest	JUnit tests for SynchBB
CBTmsg	Backtrack message in SynchBB
CPathMsg	The message containing the current partial assignment in SynchBB
CSolutionMsg	A message containing the optimal solution found so far
CSynchBB	The SynchBB algorithm for DCOPs
CConvergenceMessage	A message reporting the convergence for a given component
CClusterInfo	Information about a cluster of variables owned by this agent
CComponentInfo	The information about a particular component of the constraint graph
CSynchBBsolver	A DCOP solver using SynchBB
Ptest	Tests for the classes in the algorithms package
CAllTests	JUnit test suite for all the tests in frodo2.algorithms.dpop.test
CMASparserTest
CMessageDebugger	Prints out all messages received and sent by the agent
CProblemTest	JUnit test case for the class Problem
CSampleMASagent	A sample MAS agent that just prints its problem
CXCSPparserTest	Test suite for XCSPparser
PvarOrdering
Pdfs	Algorithms to produce pseudo-tree variable orderings
Ptests	Tests for the DFS construction algorithms
CAllTestsDFS	JUnit test suite for all the tests in frodo2.algorithms.varOrdering.dfs.tests
CDFSgenerationParallelTest	Tests the DFSgenerationParallel module
CDFSgenerationTest	JUnit test for the class DFSgeneration
CDFSgenerationWithOrderTest	JUnit for DFSgeneration with Order
CLocalRandVarsDFStest	Test case for LocalRandVarsDFS
CCHILDmsg	A token indicating that the destination variable is a child of the sender variable
CCHILDorderMsg	Child token including the order of visit of the recipient variable in the graph
CCHILDrandMsg	A CHILD token containing a set of random variables
CDFSgeneration	Distributed DFS generation protocol
CDFSview	The view of the DFS from one variable
CMessageDFSoutput	Message class used for the output of the protocol
CNextChildChoiceHeuristic	Interface for heuristics used to choose a variable's next child from its list of open neighbors
CBlindScoringHeuristic	A DFS heuristic based on a ScoringHeuristic that does not require message exchange between agents
CScoreBroadcastingHeuristic	Selects the next child as the one that has the highest score
CDFSgenerationParallel	A DFS Generation module that integrates a root election mechanism
CSinkQueue	A Queue that discards all messages sent
CFakeQueue	There is one such FakeQueue for each candidate root
CDFSgenerationWithOrder	A DFSgeneration module that also computes the order in which is variable is visited and the total number of variables in the DFS
CDFSorderOutputMessage	Carries DFS order information for one variable
CLocalRandVarsDFS	A DFS generation protocol with a heuristic for E[DPOP]
CVarElectionHeuristic	Heuristic used for variable election
CParallelDFSmsg	A message containing a DFS message for a particular candidate root, used by DFSgenerationParallel
CPSEUDOmsg	A token indicating that the destination variable is a pseudo-child of the sender variable
CRandVarsMsg	A message containing random variables
CReleaseDFSmsg	A message telling a variable to release its DFS output message, use DFSgenerationParallel
CScoreMsg	A message containing the score of a single variable
CScoresMsg	A message containing the scores of given variables
CVarNbrMsg	Msg sent to transfer through the DFS in top-down way the total number of variables in this component
Pelection	Algorithms to elect a variable
Ptests	Tests for the variable election algorithms
CAllTestsElection	JUnit test suite for all the tests in frodo2.algorithms.varOrdering.election.tests
CLeaderElectionMaxIDTest	JUnit test for the class LeaderElectionMaxID
CSecureVarElectionTest	JUnit test for the class SecureVarElection
CVarElectionMessengerTest	JUnit test for the class VarElectionMEssengerTest
CIdIncreasingVerifyer	A IncomingMsgPolicyInterface used in JUNIT VarElectionMessengerTest to test whenever ID send are strictly increasing
CVariableElectionTest	JUnit test for the class VariableElection
CLeaderElectionMaxID	This distributed leader election protocol chooses a leader agent as the one with highest unique ID
CMessageLEoutput	Message class used for the output of the protocol
CMaxIDmsg	Leader election message containing two payloads: the sender agent, and its current maxID
CSecureVarElection	A version of VariableElection that uses random numbers as scores and lies in order to protect topology privacy
CVarElectionMessenger	A version of LeaderElectionMaxID that uses random numbers as IDs and lies in order to protect topology privacy
CVariableElection	Protocol to elect a variable
Pfactorgraph
CFactorGraphGen	A factor graph generator
CFunctionNode	A function node in a factor graph
CVariableNode	A variable node in a factor graph
Plinear	Algorithms to produce linear variable orderings
Ptests	Unit tests for SynchBB
CCentralLinearOrderingTest	Unit tests for CentralLinearOrdering
CCentralLinearOrdering	Creates a linear ordering among variables
CMaxWidthMinDom	A linear ordering heuristic that chooses first variables with highest numbers of links with previous variables, breaking ties by minimizing domain size
CLinearOrdering	Distributed algorithm to compute one variable linear ordering per connected component in the constraint graph
CHeuristic	Variable ordering heuristic
CMaxWidthMinDom	A heuristic that maximizes the number of neighbors already in the order, breaking ties by minimizing the domain size, and then by variable name
CIntIntStringTuple	An (int, int, String) tuple
CComponentInfo	All relevant information about a connected component of the constraint graph
CNextVarMsg	A message containing the next variable chosen for a given component
COrderMsg	A message containing a linear order on all variables belonging to a given connected component of the constraint graph
CProposalMsg	A message containing a proposal for the next variable to put in the order
CRequestMsg	A message requesting a proposal for the next variable to put in the order
CAbstractDCOPsolver	An abstract convenient class for solving DCOP instances
CAbstractProblem	An abstract problem instance
CAbstractSolver	A solver for a general problem
CAgentFactory	A convenience class to create agents
CAgentInterface	All agents corresponding to various algorithms should implement this interface
CComStatsMessage	A message containing statistics about messages sent
CConvergence	An optimal solution to the problem
CTimeStamp	Convenience class containing a timestamp and utility value
CConvergenceInterface	Interface for all modules that should be able to store convergence data
CEavesdroppable	Defines a module that eavesdrops on the messages exchanged
CMASparser	A MASproblem parser that is able to handle multiple types of agents
CParserInterface	Interface for a parser that produces a ProblemInterface
CProblem	A ProblemInterface that does not require the use of the XCSP format
CRandGraphFactory	Generator of random graphs
CGraph	A graph
CEdge	An edge
CSingleQueueAgent	An agent that uses a single queue
CSolution	An optimal solution to the problem
CSolutionCollector	A StatsReporter that collects the generic solution to a DCOP
CAssignmentsMessage	A message holding assignments to variables
CAssignmentMessage	A message holding an assignment to a variable
CSolutionWithConvergence	An optimal solution to the problem
CStatsReporter	An interface that any listener sending statistics message should implement
CStatsReporterWithConvergence	A StatsReporter that monitors the convergence of the algorithm
CCurrentAssignment	A convenience class to store an assignment
CConvStatMessage	A message containing information about the convergence of the algorithm
CXCSPparser	An XCSP parser that provides convenient methods to extract information from XCSP files
CRelation	The representation of an XCSP relation
Pbenchmarks
Pauctions
Pcats
CAuction	This class represents an auction generated by the CATS program
CBid	This class represents a bid placed in an auction
CBidder	This class represents a bidder in the auction
CGood	This class represents a good sold in the auction
Pmain
CCATSToXCSP	This is the main class for converting a CATS (Combinatorial Auctions Test Suite) into a DCOP (Distributed Constraint Optimization Problem)
Pxcsp
CConstraint	This class is used to generate 'constraint' tags in the output XML file
CConstraints	This class is used to generate the 'constraints' tag in the output XML file
CDomain	This class is used to generate the 'domain' tags in the output XML file
CDomains	This class is used to generate the 'domains' tag in the output XML file
CInstance	This class is used to generate the 'instance' tag in the output XML file
CPresentation	This class is used to generate the 'presentation' tag of the output XML file
CRelation	This class is used to generate the 'relation' tags in the XML output file
CRelations	This class is used to generate the 'relations' tag in the XML output file
CSumParameters	This class is used to represent the parameters of an intensional sum constraint
CLessEqual	This internal class is needed to create the le XML tag; else, characters > and < are transformed into &gt and &lt
CEqual	This internal class is needed to create the eq XML tag
CVariable	This class is used to generate the 'variable' tags in the output XML file
CVariables	This class is used to generate the 'variables' tag in the output XML file
Pgraphcoloring	A graph coloring problem generator
CGraphColoring	A graph coloring problem generator
Pkidneys
CKidneyExchange	Creates a sample population of kidney donor-patient pairs and generates a graph which is then written into a DCOP problem statement
CABO	Blood types
CPRA	Panel Reactive Antibody levels
CPatientDonorPair	A patient-donor pair
Pmaxdiscsp	A Max-DisCSP problem generator
CMaxDisCSPProblemGenerator	Max-DisCSP problem generator
Pmeetings	Distributed meeting scheduling problem generator
CMeetingScheduling	Distributed meeting scheduling problem generator
CMode	The mode of encoding
Pparty	Contains a random problem generator for the party game
CPartyGame	A random problem generator for the party game
CMethod	The method used to formulate the game as a DisCSP
CPartyInstance	An instance of a party game
Pvehiclerouting
CCordeauToXCSP	A file converter from Cordeau's MDVRP format into FRODO XCSP format
CDepot	A depot
CCustomer	A customer
CXCSPparserVRP	A parser for XCSP files involving constraints of type "global:vehicle_routing"
CXCSPparserVRPODPOP	Wrapper around the XCSPparserVRP that inserts CompoundSpaces for all the variables that occur in the problem
CFileCopier	Helper utility that copies a file for use by frodo2.py when running experiments from a repository of problem instances
Pcommunication	This package contains classes that take care of communication between queues
Pmailer	Special type of communication method that enforces that only one agent is awake at a time
Ptests	Tests for the package frodo2.communication.mailer
CtestCentralMailer	Test suite for the CentralMailer
CCentralMailer	Centralized mail man that enforces that only one agent is awake at a time, which is useful to measure distributed runtime
CFakeQueue	The queue associated with a specific agent
CTimestampComparator	A comparator used in the PriorityQueue to order messages according to their timestamps
CDelayGenerator	Abstract class that defines the functions needed in a delay generator
CNegativeExponentialDistribution	This class is used to generate message delay according to the negative exponential distribution
PsharedMemory	Contains classes used for communication between agents running within the same JVM
CQueueIOPipe	Input-output pipe between two queues
CQueueIOPipeTest	JUnit class to test QueueIOPipe
CCollector	A listener that collects received messages
Ptcp	Contains classes used for communication between agents via TCP
CQueueInputPipeTCP	This is a queue input pipe that receives messages through TCP
CReceiver	Whenever a request for connection is received, one such a thread is spawn to establish the connection
CQueueInputPipeTCPTest	A JUnit test class for QueueInputPipeTCP
CSender	A client that connects to the queue and to send serialized messages through TCP
CQueueOutputPipeTCP	This is a queue output pipe that sends messages through TCP
CRawDataInfo	A convenience class used to store information about raw data
CRawDataSender	A thread that listens for requests to serialize or discard raw data
CRawDataServer	The thread responsible for waiting for requests for raw data
CQueueOutputPipeTCPTest	A JUnit test class for QueueOutputPipeTCP, that uses QueueInputPipeTCP
CRawDataHandlerTCP	A raw data handler that works with TCP
CTCPAddress	A TCP/IP-port address
CTCPPipeFactory
CAgentAddress	The address for an agent
CAllTests	JUnit test suite for all unit tests in this package
CIncomingMsgPolicyInterface	This interface describes a listener that is notified by a queue of incoming messages
CMessage	Base class used for messages exchanged between queues
CMessageListener	A general interface for modules listening for messages
CMessageSerializedSimple	A message that has a single object as raw data
CMessageType	The (hierarchical) type of a message
CMessageWith2Payloads	A message that has two objects of generic types as a payload
CMessageWith3Payloads	A message that has three objects of generic types as a payload
CMessageWith4Payloads	A message that has three objects of generic types as a payload
CMessageWith5Payloads	A message that has three objects of generic types as a payload
CMessageWithPayload	A message that has a single object of generic type as a payload
CMessageWithRawData	A message containing data that must be custom-serialized
CRawDataHandler	This class is responsible for handling the raw data
CMessageWrapper	Message wrapper, used to store information on
CMsgSizeMonitor	Measures message sizes using serialization
CMsgSizeMonitorTest	Unit tests for the MsgSizeMonitor
COutgoingMsgPolicyInterface	This interface describes a listener that is notified by a queue of outgoing messages
CDecision	The decision made
CPipeFactory
CQueue	A queue
CQueueInputPipeInterface	Interface for classes used as an input to a Queue object
CQueueOutputPipeInterface	Interface for classes used as an output of a Queue object
CQueueTest	A JUnit class to test Queue
CQueueInputPipeTrivial	This pipe has a list of messages ready to be pulled using pullMessage()
CQueueOutputPipeTrivial	This pipe stores the messages passed to it using pushObject()
CConstantMsgPolicy	A message policy that always returns the same decision
Pcontroller
Pmessages
CMessageAgentReporting
PtestFiles
CTestAgent	Does the following:
PuserIO
CConsole	A simple console based user interface
CDistributedSolver	An interface to the Controller (and a wrapper thereof) that is based on a solver
CFakeFactory	A fake agent factory
CUserIO	This class implements all the functions that a user interface should deliver
CAllTests	JUnit test suite for all unit tests in this package
CConfigurationManager	The ConfigurationManager takes care of setting up the experiments
CController	The controller class, a container for the listeners that do the actual work
CDistributedSolverDemo	A demo for the distributed solver
CTestConfigurationManager	A JUnit test class for the configuration manager
CSimpleDaemonListener	A simple class that listens for messages sent to a daemon
CTestController
CControllerExtension	An extension of the controller that allows external objects to
CDaemonExtension	A daemon with an API to pass the configuration file
CTestWhitePages
CWhitePagesExtention	Extention of the white pages that enables one to get the list of daemons, the list of agents and the local address of the white pages
CWhitePages
Pdaemon
PuserIO
CConsole	A simple console based user interface
CUserIO
CAllTests	JUnit test suite for all unit tests in this package
CConstructor
CDaemon
CLocalAgentReport	A message that an agent sends to its local white pages to report
CLocalConfigManager	A local configuration manager that parses configuration files passed to the daemon
CLocalWhitePages
CTestLocalWhitePages
CSimpleAgent	A simple agent for testing purposes
CLocalWhitePagesExtension	An extension of the local white pages that is able to return the list of agents
Pgui
Pjung
CJungVisualizer	A Visualizer using JUNG2
CConsoleVisualizer	A simplistic visualizer that just prints to the console
CDOTrenderer	Renders and displays DOT code
CSimpleGUI	A simple GUI to configure and start FRODO
CVisualizer	An interface for visualizing agents, variables, constraints, and message exchanges
CMsgVisualization	Whether and how long to display a message type
CVisualizerControls	A GUI to control how long messages are displayed
CMsgTypeSetting	A message type and its slider
CMsgTypeRenderer	Renders each node in the tree as a message type name and a slider
PsolutionSpaces	This package contains interfaces for various representations of solution spaces
Pcrypto
CAddableBigInteger	An Addable number based on a BigInteger
CMinInfinity	This class implements the minus infinity element
CPlusInfinity	This class implements the plus infinity element
CAddableBigIntegerDelayed	Class used to speed up n-ary additions and multiplications
CCryptoScheme	Defines a way to encrypt and decrypt information
CPublicKeyShare	One share of the overall public key
CElGamalBigInteger	ElGamal encryption of an integer
CElGamalScheme	The ElGamal crypto scheme
CElGamalPublicKeyShare	A public key share
CElGamalSchemeTest	Junit Class to test the ElGamalScheme
Phypercube	Classes implementing hypercubes, which are explicit table spaces
Ptests	The hypercube tests
CAllTestsHypercube	The hypercube tests
CHypercubeIterBestFirstTest
CHypercubeIterTest	JUnit tests for the BasicHypercube iterator
CHypercubeTest	A class used to test the Hypercube class
CInfinity	Variables are used to determine whether infinite values are allowed
CBasicHypercube	A basic hypercube that stores one utility per combination of assigments to variables
CBasicHypercubeIter	A solution iterator for BasicHypercubes
CBlindProjectOutput	The output of a blindProject() that computes itself on the fly
CMyIter	This class' special iterator
CExpectationOutput	The output of expectation(), computed on the fly
CMyIter	This class' special iterator
CHypercube	The class representing a hypercube
CNullHypercube	Class representing a NULL hypercube
CHypercubeIter	An iterator for a Hypercube
CHyperCubeIterBestFirst	An iterator in best-first order
CAssignment	Class containing a single assignment with its utility
CMaximizeComp	Comparator used when maximizing
CMinimizeComp	Comparator used when minimizing
CHypercubeLimited	A Hypercube whose utilities are AddableLimited's
CJoinOutputHypercube	The special output of a join that remembers its inputs rather than computing itself explicitly
CJoinOutputIterator	An iterator for a JoinOutputHypercube
CScalarBasicHypercube	A BasicHypercube that contains only one utility, and no variables
CScalarBasicSpaceIter	A solution iterator for a scalar space
CScalarHypercube	A hypercube that contains no variables, but a single utility value
CScalarHypercubeLimited	A HypercubeLimited that contains no variable and a single utility
CScalarSpaceIter	A solution iterator for a scalar space
PJaCoP	Package handling the interface with the JaCoP solver
Ptests	The hypercube tests
CAllTestsJaCoP	The JaCoP tests
CJaCoPproblemTest	A JUnit TestCase for the JaCoPproblem class
CJaCoPtests	JUnit test for JaCoPutilSpace
CAlgorithm	The different algorithms to be tested
CJaCopxcspParserTest	Test suite for JaCopxcspParser
CExtensionalSupportHypercube	A JaCoP extensional constraint encoded by a hypercube for faster lookups
CIterSolutionListener	This solution listener is a part of the JaCoPutilSpace iterator that allows us to simulate a JaCoP master/slave search combination where the slave is an optimization search while the master is not
CJaCoPiterSearch	A wrapper around a JaCoP DepthFirstSearch that is used to run this search in a new thread
CJaCoPoptAssignments	Conditional optimal assignment(s) to several variables
CJaCoPproblem	A DCOP problem that is defined using JaCoP variables and constraints
CJaCoPutilSpace	A UtilitySolutionSpace based on JaCoP as a local solver
CJaCoPutilSpaceIter	A solution iterator for JaCoPutilSpace
CJaCoPutilSpaceIter2	A solution iterator for JaCoPutilSpace that runs a JaCoP search in an extra thread
CJaCoPutilSpaceIterBestFirst	A solution iterator in best first order for JaCoPutilSpace
CJaCoPxcspParser	An XCSP parser that generates spaces based on JaCoP
CConstraintType	Constraint type
CPredicate	Predicate wrapper that translates a predicate expression from XCSP into constraints available in JaCoP
Ptests	All solution spaces tests
CAllTestsSpaces	All solution spaces tests
Pvehiclerouting
Ptest
CVRPtests	JUnit tests for the Vehicle Routing Problem benchmarks
CCompoundSpace
CBestFirstIterator	Best first iterator for the combination of a VehicleRoutingSpace with a collection of sum constraints
CCustomer	A customer in the Vehicle Routing Problem
CVehicleRoutingSpace	A solution space for Vehicle Routing Problems
CVRPiterator	Iterator
CVRPiteratorBestFirst	Best first iterator
CCustomerAssignment	Convenience class used by the iterator
CAddable	Defines the methods add() and also multiply()
CAddableBigDecimal	An arbitrary-precision real number that implements Addable
CMinInfinity	This class implements the minus infinity element
CPlusInfinity	This class implements the plus infinity element
CAddableBigDecimalDelayed	Class used to speed up n-ary additions and multiplications
CAddableConflicts
CAddableDelayed
CAddableInteger
CPlusInfinity	This class implements the plus infinity element
CMinInfinity	This class implements the minus infinity element
CAddableIntegerDelayed	Class used to make the addition of a large number of integers more efficient
CAddableLimited	A limited Addable that only declares a very small subset of the operations supported by an Addable
CAddableReal	Class representing a real number
CPlusInfinity	A singleton class representing the real number +infinity
CMinInfinity	A singleton class representing the real number -infinity
CAddableRealDelayed	Class used to make the addition of a large number of reals more efficient
CBasicUtilitySolutionSpace	This interface defines common functionalities in all utility solution spaces
CSparseIterator	A BasicUtilitySolutionSpace iterator that skips infeasible solutions
CIterator	A BasicUtilitySolutionSpace iterator that doest NOT skip infeasible solutions
CDCOPProblemInterface	The subproblem to be solved by a given agent
CMASProblemInterface
CProblemInterface	A general problem
CSolutionSpace	This interface defines common functionalities in all solution spaces
CSparseIterator	A SolutionSpace iterator that skips infeasible solutions
CIterator	An iterator that does NOT skip infeasible solutions
CUtilitySolutionSpace	This interface defines common functionalities in utility solution spaces in which the utilities are Addable
CProjOutput	The result of a projection
CSparseIterator	A UtilitySolutionSpace iterator that skips infeasible solutions
CIterator	A UtilitySolutionSpace iterator that does NOT skip infeasible solutions
CIteratorBestFirst	A BasicUtilitySolutionSpace iterator that returns items in a best first order
CUtilitySolutionSpaceLimited	A UtilitySolutionSpace whose utilities implement AddableLimited
Porg
Pjacop
Pconstraints
Pbinpacking
CBinpackingCloneable	A cloneable version of the Binpacking constraint
Pcumulative
CCumulativeBasicCloneable	A cloneable version of the CumulativeBasic constraint
CCumulativeCloneable	A cloneable version of the Cumulative constraint
CCumulativeOptionalCloneable	A Cloneable version of CumulativeOptional
CCumulativePrimaryCloneable	A cloneable version of the CumulativePrimary constraint
CCumulativeUnaryCloneable	A cloneable version of the CumulativeUnary constraint
CCumulativeUnaryOptionalCloneable	A Cloneable variant of CumulativeUnaryOptional
Pdiffn
CDiffnCloneable	A cloneable version of the Diffn constraint
CDiffnDecomposedCloneable	A cloneable version of the DiffnDecomposed constraint
CNooverlapCloneable	A cloneable version of the Nooverlap constraint
Pgeost
CExternalConstraintCloneable	A cloneable version of ExternalConstraint
CGeostCloneable	A cloneable version of the Geost constraint
CGeostObjectCloneable	A cloneable version of GeostObject
CInAreaCloneable	A cloneable version of InArea
CNonOverlappingCloneable	A cloneable version of NonOverlapping
CShapeCloneable	A cloneable version of Shape
Pknapsack
CKnapsackCloneable	A cloneable version of the Knapsack constraint
Pnetflow
CArithmeticCloneable	A cloneable version of the Arithmetic constraint
CArithmeticBuilderCloneable	A cloneable version of ArtithmeticBuilder
CNetworkBuilderCloneable	A cloneable version of NetworkBuilder
CNetworkFlowCloneable	A cloneable version of the NetworkFlow constraint
Pregular
CRegularCloneable	A cloneable version of the Regular constraint
Ptable
CSimpleTableCloneable	A cloneable version of the SimpleTable constraint
CTableCloneable	A cloneable version Table constraint
CAbsXeqYCloneable	A cloneable version of the AbsXeqY constraint
CAlldiffCloneable	A cloneable version of the Alldiff constraint
CAlldifferentCloneable	A cloneable version of the Alldifferent constraint
CAlldistinctCloneable	A cloneable version of the Alldistinct constraint
CAllEqualCloneable	A Cloneable version of the AllEqual constraint
CAmongCloneable	A cloneable version of the Among constraint
CAmongVarCloneable	A cloneable version of the AmongVar constraint
CAndBoolCloneable	A cloneable version of the AndBool constraint
CAndBoolSimpleCloneable	A cloneable version of the AndBoolSimple constraint
CAndBoolVectorCloneable	A cloneable version of the AndBoolVector constraint
CAndCloneable	A cloneable version of the And constraint
CArgMaxCloneable	A cloneable version of the ArgMax constraint
CArgMinCloneable	A cloneable version of the ArgMin constraint
CAssignmentCloneable	A cloneable version of the Assignment constraint
CAtLeastCloneable	A cloneable version of the AtLeast constraint
CAtMostCloneable	A cloneable version of the AtMost constraint
CBoolClauseCloneable	A cloneable version of the BoolClause constraint
CChannelImplyCloneable	A cloneable variant of the ChannelImply constraint
CChannelReifCloneable	A cloneable variant of the ChannelReif constraint
CCircuitCloneable	A cloneable version of the Circuit constraint
CConditionalCloneable	A cloneable version of Conditional
CConstraintCloneableInterface	A constraint is clonable if a state-less copy of it can be created into a target store
CCountBoundsCloneable	A cloneable version of the CountBounds constraint
CCountCloneable	A cloneable version of the Count constraint
CCountValuesBoundsCloneable	A cloneable version of the CountValuesBounds constraint
CCountValuesCloneable	A cloneable version of the CountValues constraint
CCountVarCloneable	A cloneable version of the CountVar constraint
CCumulativeCloneable	A cloneable version of the Cumulative constraint
CDecomposedConstraintCloneableInterface	An interface that defines additional methods for a DecomposedConstraint
CDecreasingCloneable	A cloneable variant of the Decreasing constraint
CDiff2Cloneable	A cloneable version of the Diff2 constraint
CDiffCloneable	A cloneable version of the Diff constraint
CDisjointCloneable	A cloneable version of the Disjoint constraint
CDisjointConditionalCloneable	A cloneable version of the DisjointConditional constraint
CDistanceCloneable	A Cloneable version of the Distance constraint
CElementIntegerCloneable	A cloneable version of the ElementInteger constraint
CElementIntegerFastCloneable	A cloneable version of the ElementIntegerFast constraint
CElementVariableCloneable	A cloneable version of the ElementVariable constraint
CElementVariableFastCloneable	A cloneable version of the ElementVariableFast constraint
CEqBoolCloneable	A cloneable version of the EqBool constraint
CEqCloneable	A cloneable version of the Eq constraint
CExtensionalConflictVACloneable	A cloneable version of the ExtensionalConflictVA constraint
CExtensionalSupportMDDCloneable	A cloneable version of the ExtensionalSupportMDD constraint
CExtensionalSupportSTRCloneable	A cloneable version of the ExtensionalSupportSTR constraint
CExtensionalSupportVACloneable	A cloneable version of the ExtensionalSupportVA constraint
CGCCCloneable	A cloneable version of the GCC constraint
CIfThenBoolCloneable	A cloneable version of the IfThenBool constraint
CIfThenCloneable	A cloneable version of the IfThen constraint
CIfThenElseCloneable	A cloneable version of the IfThenElse constraint
CImpliesCloneable	A cloneable version of the Implies constraint
CInCloneable	A cloneable version of the In constraint
CIncreasingCloneable	A cloneable variant of the Increasing constraint
CLexCloneable	A cloneable version of the Lex constraint
CLexOrderCloneable	A cloneable version of the LexOrder constraint
CLinearIntCloneable	A cloneable LinearInt constraint
CLinearIntDomCloneable	A cloneable version of the LinearIntDom constraint
CMaxCloneable	A cloneable version of the Max constraint
CMaxSimpleCloneable	A cloneable version of the MaxSimple constraint
CMemberCloneable	A cloneable version of the Member constraint
CMinCloneable	A cloneable version of the Min constraint
CMinSimpleCloneable	A cloneable version of the MinSimple constraint
CNoGoodCloneable	A cloneable version of the NoGood constraint
CNotCloneable	A cloneable version of the Not constraint
COrBoolCloneable	A cloneable variant of the OrBool constraint
COrBoolSimpleCloneable	A cloneable version of the OrBoolSimple constraint
COrBoolVectorCloneable	A cloneable variant of the OrBoolVector constraint
COrCloneable	A cloneable version of the Or constraint
CReifiedCloneable	A cloneable version of the Reified constraint
CSeqPrecedeChainCloneable	A Cloneable version of the SeqPrecedeChain constraint
CSequenceCloneable	A cloneable version of the Sequence constraint
CSoftAlldifferentCloneable	A cloneable version of the SoftAllDifferent constraint
CSoftAlldiffBuilderCloneable	A NetworkBuilder for SoftAlldifferent
CSoftGCCCloneable	A cloneable version of the SoftGCC constraint
CSoftGCCBuilderCloneable	A NetworkBuilder for SoftGCCCloneable
CStretchCloneable	A cloneable version of the Stretch constraint
CSubcircuitCloneable	A cloneable version of the Subcircuit constraint
CSumBoolCloneable	A cloneable SumBool constraint
CSumCloneable	A cloneable version of the Sum constraint
CSumIntCloneable	A clonable version of JaCoP's SumInt constraint
CSumWeightCloneable	A cloneable version of the SumWeight constraint
CValuePrecedeCloneable	A cloneable version of the ValuePrecede constraint
CValuesCloneable	A cloneable version of the Values constraint
CXdivYeqZCloneable	A cloneable version of the XdivYeqZ constraint
CXeqCCloneable	A cloneable version of the XeqC constraint
CXeqYCloneable	A cloneable version of the XeqY constraint
CXexpYeqZCloneable	A cloneable version of the XexpYeqZ constraint
CXgtCCloneable	A cloneable version of the XqtC constraint
CXgteqCCloneable	A cloneable version of the XgteqC constraint
CXgteqYCloneable	A cloneable version of the XgteqY constraint
CXgtYCloneable	A cloneable version of the XgtY constraint
CXltCCloneable	A cloneable version of the XltC constraint
CXlteqCCloneable	A cloneable version of the XlteqC constraint
CXlteqYCloneable	A cloneable version of the XlteqY constraint
CXltYCloneable	A cloneable version of the XltY constraint
CXmodYeqZCloneable	A cloneable version of the XmodYeqZ constraint
CXmulCeqZCloneable	A cloneable version of the XmulCeqZ constraint
CXmulYeqCCloneable	A cloneable version of the XmulYeqC constraint
CXmulYeqZCloneable	A cloneable version of the XmulYeqZ constraint
CXneqCCloneable	A cloneable version of the XneqC constraint
CXneqYCloneable	A cloneable version of the XneqY constraint
CXorBoolCloneable	A cloneable variant of the XorBool constraint
CXorCloneable	A cloneable version of the Xor constraint
CXplusCeqZCloneable	A cloneable version of the XplusCeqZ constraint
CXplusClteqZCloneable	A cloneable version of the XplusClteqZ constraint
CXplusYeqCCloneable	A version of the XplusYeqC constraint
CXplusYeqZCloneable	A cloneable version of the XplusYeqZ interface
CXplusYgtCCloneable	A cloneable version of the XplusYgtC constraint
CXplusYlteqZCloneable	A cloneable version of the XplusYlteqZ constraint
Pcore
CCloneableInto	An interface for JaCoP variables that are cloneable into another store
CIntVarCloneable	A JaCoP IntVar that is cloneable into a store
CStoreCloneable	A JaCoP store that support cloning
Putil
Pfsm
CFSMCloneable	A cloneable FSM
CMDDCloneable	A version of MDD that requires cloneable variables