Uses of Class
solvers.dataStructures.PopulationVector

Packages that use PopulationVector

Package	Description
solvers.dataStructures	Data structures shared by the JMVA solvers (tuples, positions, lists and matrices).
solvers.linearSystem	Linear system formulation shared by the MoM and CoMoM exact algorithms of JMVA.
solvers.linearSystem.btf	Block Triangular Form (BTF) of the linear systems arising in the MoM and CoMoM algorithms, as described in the method of moments literature.
solvers.linearSystem.simple	Simple linear system solvers used by JMVA.
solvers.queueingnet	Queueing network model of JMVA: stations, classes, service demands and visits used by the exact and approximate solution algorithms.
solvers.queueingnet.treeAlgorithms	Tree based exact algorithms of JMVA: TreeMVA and TreeConvolution, which reduce the complexity of the exact solution of large closed models.
solvers.queueingnet.treeAlgorithms.tmva	TreeMVA algorithm of JMVA, the tree based version of the exact Mean Value Analysis.
solvers.queueingnet.treeAlgorithms.treeConvolution	TreeConvolution algorithm of JMVA, the tree based version of the convolution algorithm.

Uses of PopulationVector in solvers.dataStructures

Fields in solvers.dataStructures declared as PopulationVector

Modifier and Type	Field	Description
PopulationVector	QNModel.N	Contains total number of jobs for each class

Methods in solvers.dataStructures that return PopulationVector

Modifier and Type	Method	Description
PopulationVector	PopulationVector.addVec(EnhancedVector b)
PopulationVector	PopulationVector.changePopulation(PopulationChangeVector n)	Changes the population by subtracting the supplied Population Change Vector
PopulationVector	PopulationVector.copy()	This method returns a copy of the current PopulationVector object.
PopulationVector	QNModel.getPopulationVector()	This method returns a copy of the current PopulationVector with the values contained in this QNModel object (quening network model).
PopulationVector	PopulationVector.subVec(EnhancedVector b)

Methods in solvers.dataStructures with parameters of type PopulationVector

Modifier and Type	Method	Description
boolean	PopulationVector.anyGreaterThan(PopulationVector a)

Uses of PopulationVector in solvers.linearSystem

Methods in solvers.linearSystem with parameters of type PopulationVector

Modifier and Type	Method	Description
final void	LinearSystem.initialiseForClass(PopulationVector current_N, int current_class)	Initialises the linear system ready for iteration on current_class at the specified population
protected abstract void	LinearSystem.initialiseMatricesForClass(PopulationVector current_N, int current_class)	Initialises the matrices of the linear system ready for iteration on current_class at the specified population

Uses of PopulationVector in solvers.linearSystem.btf

Methods in solvers.linearSystem.btf with parameters of type PopulationVector

Modifier and Type	Method	Description
void	BTFLinearSystem.initialiseMatricesForClass(PopulationVector current_N, int current_class)

Uses of PopulationVector in solvers.linearSystem.simple

Methods in solvers.linearSystem.simple with parameters of type PopulationVector

Modifier and Type	Method	Description
void	SimpleLinearSystem.initialiseMatricesForClass(PopulationVector current_N, int current_class)

Uses of PopulationVector in solvers.queueingnet

Fields in solvers.queueingnet with type parameters of type PopulationVector

Modifier and Type	Field	Description
protected Map<PopulationVector, Map<MultiplicitiesVector, BigRational>>	RecursiveSolver.Gmap	Here is stored every normalising constant computed.

Methods in solvers.queueingnet with parameters of type PopulationVector

Modifier and Type	Method	Description
BigRational	ConvolutionSolver.compute(MultiplicitiesVector m, PopulationVector p)	Computes any normalising constant using a simple recursion and taking advantage of any already computed and stored value.
protected BigRational	RECALNonRecursiveSolver.compute(MultiplicitiesVector finalm, PopulationVector finalp)	Computes any normalising constant non-recursively and by taking advantage of any already computed and stored value.
protected BigRational	RECALSolver.compute(MultiplicitiesVector m, PopulationVector p)	Computes any normalising constant using a simple recursion and taking advantage of any already computed and stored value.
protected BigRational	RecursiveSolver.compute(MultiplicitiesVector m, PopulationVector p)	Computes any normalising constant using a simple recursion and taking advantage of any already computed and stored value.
protected BigRational	RGFSolver.compute(MultiplicitiesVector m, PopulationVector p, int q, BigRational[][] load)
protected BigRational	RecursiveSolver.findG(MultiplicitiesVector m, PopulationVector p)	Searches for a normalising constant in the memory.
protected BigRational	RecursiveSolver.initialConditionFor(PopulationVector n)	Returns the initial condition corresponding to a particular PopulationVector object.
protected BigRational	RecursiveSolver.recallG(MultiplicitiesVector m, PopulationVector p)	Searches for a normalising constant in the memory.
protected void	RecursiveSolver.storeG(MultiplicitiesVector m, PopulationVector p, BigRational Gval)	Stores a computed normalising constant value for future re-use.
protected void	RecursiveSolver.storeG(MultiplicitiesVector m, PopulationVector p, BigRational Gval, Map<PopulationVector, Map<MultiplicitiesVector, BigRational>> map)	Stores at a particular Map<PopulationVector, Map<MultiplicitiesVector, BigRational>> data structure a computed normalising constant value for future re-use.

Method parameters in solvers.queueingnet with type arguments of type PopulationVector

Modifier and Type	Method	Description
protected void	RecursiveSolver.storeG(MultiplicitiesVector m, PopulationVector p, BigRational Gval, Map<PopulationVector, Map<MultiplicitiesVector, BigRational>> map)	Stores at a particular Map<PopulationVector, Map<MultiplicitiesVector, BigRational>> data structure a computed normalising constant value for future re-use.

Uses of PopulationVector in solvers.queueingnet.treeAlgorithms

Fields in solvers.queueingnet.treeAlgorithms with type parameters of type PopulationVector

Modifier and Type	Field	Description
HashMap<PopulationVector, HashMap<PopulationVector, BigDecimal>>	Node.backupGmaps	In certain cases when we store multiple Gmaps at a node, backupGmaps can be used to store these extra Gmaps, else this remains unused.
HashMap<PopulationVector, HashMap<PopulationVector, BigDecimal>>	Node.backupGmaps	In certain cases when we store multiple Gmaps at a node, backupGmaps can be used to store these extra Gmaps, else this remains unused.
HashMap<PopulationVector, BigDecimal>	Node.Gmap	The partially covered g-array for this node.
HashMap<PopulationVector, MVAResults>	Node.mvaRes	Tree MVA related

Methods in solvers.queueingnet.treeAlgorithms that return PopulationVector

Modifier and Type	Method	Description
PopulationVector	ClassCoverageUtils.contract(PopulationVector largePopVec, TreeSet<Integer> largePcs, TreeSet<Integer> smallPcs)	Contracts a population vector to the necessary size depending on partially covered classes in smallPcs.
PopulationVector	ClassCoverageUtils.expand(PopulationVector oldPopVec, TreeSet<Integer> oldPcs, PopulationVector newPopVec, TreeSet<Integer> newPcs)	Expands a population vector to the necessary size depending on partially covered classes in newPcs.
PopulationVector	ClassCoverageUtils.nextPermutation(PopulationVector pv, PopulationVector orig)	Returns the next permutation of a population vector to be used in the convolution computation, given the current vector and the original start vector.
PopulationVector	ClassCoverageUtils.nextPermutationUpwards(PopulationVector pv, PopulationVector orig)	Returns the next permutation of a population vector to be used in the convolution computation, given the current vector and the original start vector.

Methods in solvers.queueingnet.treeAlgorithms with parameters of type PopulationVector

Modifier and Type	Method	Description
boolean	Node.backupContains(PopulationVector p)	Checks whether the backup g-array store contains the population vector.
boolean	Node.childrenOverlappedPcsHaveLargePopulation(PopulationVector popVec)	Checks whether this node's children have a large population overlap in their partially covered classes.
abstract void	TreeTraverser.computeSubnetNode(Node node, PopulationVector pv)	Abstract method which an extending class will override to define subnetwork node computations.
PopulationVector	ClassCoverageUtils.contract(PopulationVector largePopVec, TreeSet<Integer> largePcs, TreeSet<Integer> smallPcs)	Contracts a population vector to the necessary size depending on partially covered classes in smallPcs.
PopulationVector	ClassCoverageUtils.expand(PopulationVector oldPopVec, TreeSet<Integer> oldPcs, PopulationVector newPopVec, TreeSet<Integer> newPcs)	Expands a population vector to the necessary size depending on partially covered classes in newPcs.
BigDecimal	Node.getBackupG(PopulationVector p)	Returns the first value in the backup g-array for specified population vector (at the root this will be the normalisation constant).
BigDecimal	Node.getBackupGarr(PopulationVector p1, PopulationVector p2)	Gets a g-array values from the backup g-array store using the specified backup and key population vectors.
abstract Thread	TreeTraverserMulti.getComputeLeafNodeThread(Node node, PopulationVector pv)	Abstract method which an extending class will override to define leaf node computations.
BigDecimal	Node.getGarr(PopulationVector p)	Gets a g-array values from the single g-array store at the specified population vector.
protected abstract ComplexityEvaluator.ComplexityBundle	ComplexityEvaluator.getLeafNodeComplexity(Node node, PopulationVector pv)	Gets the complexity of a leaf node computation in the tree algorithm.
MVAResults	Node.getMVARes(PopulationVector N)	Retrieves the stored MVA results for a specified population vector.
protected abstract ComplexityEvaluator.ComplexityBundle	ComplexityEvaluator.getStandardAlgorithmComplexity(PopulationVector pv)	Gets the complexity of running standard/sequential algorithm over a network with the specified population vector.
protected abstract ComplexityEvaluator.ComplexityBundle	ComplexityEvaluator.getSubnetNodeComplexity(Node node, PopulationVector pv)	Gets the complexity of a subnetwork node computation in the tree algorithm.
abstract Thread	TreeTraverserMulti.getSubnetNodeThread(Node node, PopulationVector pv)	Abstract method which an extending class will override to define subnetwork node computations.
protected ComplexityEvaluator.ComplexityBundle	ComplexityEvaluator.getTreeComplexity(Node node, PopulationVector pv)	Gets the complexity of running the tree algorithm over the specified tree.
int	ComplexityEvaluator.getTreeWithBestComplexity(Node[] roots, PopulationVector pv)	Determines which tree from a list has the best complexity characteristics.
abstract void	TreeTraverser.initLeafNode(Node node, PopulationVector pv)	Abstract method which an extending class will override to define leaf node computations.
void	TreeTraverser.iterativeTraverse(Node root, PopulationVector pv)	Iteratively traverses a tree from the specified node in a post-order fashion, performing computations at each node.
PopulationVector	ClassCoverageUtils.nextPermutation(PopulationVector pv, PopulationVector orig)	Returns the next permutation of a population vector to be used in the convolution computation, given the current vector and the original start vector.
PopulationVector	ClassCoverageUtils.nextPermutationUpwards(PopulationVector pv, PopulationVector orig)	Returns the next permutation of a population vector to be used in the convolution computation, given the current vector and the original start vector.
void	TreeTraverser.recursiveTraverse(Node node, PopulationVector pv)	Recursively traverses a tree from the specified node in a post-order fashion, performing computations at each node.
void	Node.store(PopulationVector backupVector, PopulationVector key, BigDecimal value, boolean backup)	Stores a nromalisation constant locally.
void	TreeTraverserMulti.traverse(Node node, PopulationVector pv)	Runs a recursive multi-threaded traversal and waits for the result.
abstract boolean	ComplexityEvaluator.treeHasAcceptableComplexity(Node root, PopulationVector pv)	Determines if the tree algorithm for the specified tree has better complexity characteristics than the standard/sequential algorithm for the same network.

Uses of PopulationVector in solvers.queueingnet.treeAlgorithms.tmva

Methods in solvers.queueingnet.treeAlgorithms.tmva with parameters of type PopulationVector

Modifier and Type	Method	Description
void	SingleThreadTMVASolver.computeSubnetNode(Node node, PopulationVector pv)	Method to run at the parent's of leaf nodes in the TMVA tree.
Thread	MultiThreadTMVASolver.getComputeLeafNodeThread(Node node, PopulationVector pv)	Computes results at a leaf node by creating a suitable thread to run the computation.
protected ComplexityEvaluator.ComplexityBundle	TMVAComplexityEvaluator.getLeafNodeComplexity(Node node, PopulationVector pv)	Gets the complexity of a leaf node computation in the TMVA algorithm.
protected ComplexityEvaluator.ComplexityBundle	TMVAComplexityEvaluator.getStandardAlgorithmComplexity(PopulationVector pv)	Gets the complexity of running standard/sequential MVA algorithm over a network with the specified population vector.
protected ComplexityEvaluator.ComplexityBundle	TMVAComplexityEvaluator.getSubnetNodeComplexity(Node node, PopulationVector pv)	Gets the complexity of a subnetwork node computation in the TMVA algorithm.
Thread	MultiThreadTMVASolver.getSubnetNodeThread(Node node, PopulationVector pv)	Computes results at a subnetwork node by creating a suitable thread to run the computation.
void	SingleThreadTMVASolver.initLeafNode(Node node, PopulationVector pv)	Method to run at leaf nodes in the TMVA tree.
MVAResults	StandardMVASolver.sequentialMVA(Node node, PopulationVector N)
MVAResults	IThreadedTMVASolver.solve(Node node, PopulationVector N)	Solves the network rooted at the specified node.
MVAResults	MultiThreadTMVASolver.solve(Node node, PopulationVector N)	Solves the network rooted at the specified node using TMVA.
MVAResults	SingleThreadTMVASolver.solve(Node node, PopulationVector N)	Solves the network rooted at the specified node.
MVAResults	StandardMVASolver.solve(Node node, PopulationVector N)	Solves the network rooted at the specified node.
boolean	TMVAComplexityEvaluator.treeHasAcceptableComplexity(Node root, PopulationVector pv)	Determines if the TMVA for the specified tree has better complexity characteristics than the standard/sequential MVA algorithm for the same network.

Uses of PopulationVector in solvers.queueingnet.treeAlgorithms.treeConvolution

Methods in solvers.queueingnet.treeAlgorithms.treeConvolution with parameters of type PopulationVector

Modifier and Type	Method	Description
BigRational[][]	IThreadedTCSolver.calculateMeanQueueLengths(PopulationVector p)	Calculates per class and per station mean queue lengths using methods outlined in LamLien83 paper.
BigRational[][]	MultiThreadTCSolver.calculateMeanQueueLengths(PopulationVector p)	Calculates per class and per station mean queue lengths using methods outlined in LamLien83 paper.
BigRational[][]	SingleThreadTCSolver.calculateMeanQueueLengths(PopulationVector p)	Calculates per class and per station mean queue lengths using methods outlined in LamLien83 paper.
BigRational[]	IThreadedTCSolver.calculateThroughputs(PopulationVector p)	Calculates per class throughputs using methods outlined in LamLien83 paper.
BigRational[]	MultiThreadTCSolver.calculateThroughputs(PopulationVector p)	Calculates per class throughputs using methods outlined in LamLien83 paper.
BigRational[]	SingleThreadTCSolver.calculateThroughputs(PopulationVector p)	Calculates per class throughputs using methods outlined in LamLien83 paper.
BigRational	IThreadedTCSolver.computeG(Node node, PopulationVector pv)	Compute G using postorder tree traversal.
BigRational	MultiThreadTCSolver.computeG(Node node, PopulationVector pv)	Computes G using postorder tree traversal.
BigRational	SingleThreadTCSolver.computeG(Node node, PopulationVector pv)	Computes G using postorder tree traversal.
BigRational[]	ConvolutionLayer.computeGmPlusStoreMultiple(Node cloneParent, PopulationVector p, int m)	Calculates Gm+(n-1_k) by storing multiple g arrays, one for each partially covered class in pc.
BigRational[]	ConvolutionLayer.computeGmPlusStoreSingle(Node cloneParent, PopulationVector p, int m)	Calculates Gm+(n-1_k) using first method from section 4.2 in Lam/Lien paper.
BigRational	ConvolutionLayer.computeGNminusOneMethod1(Node root, int k, PopulationVector pv)	Computes the normalisation constant G(N - 1_k) for the specified class k, required to calculate the chain throughputs.
void	ConvolutionCore.computeLeafNodeGArray(Node n, PopulationVector popVec, boolean backup)	Computes the g-array at the specified leaf node by implementing Eq.
void	ConvolutionLayer.computeLeafNodeGArray(Node node, PopulationVector popVec)	Wraps the computation of leaf node g-arrays so that the solvers do not need direct access to the convolution core.
void	SingleThreadTCSolver.computeSubnetNode(Node node, PopulationVector pv)	Computes results at subnetwork node by delegating to the convolution layer.
void	ConvolutionCore.computeSubnetNodeGArray(Node node, PopulationVector popVec, boolean backup)	Computes the g-array at the specified subnet (non-leaf) node.
void	ConvolutionLayer.computeSubnetNodeGArray(Node node, PopulationVector popVec)	Wraps the computation of subnet node g arrays so that the solvers do not need direct access to the convolution core.
void	ConvolutionCore.feedbackFilter(Node parentNode, PopulationVector parentPcMax, PopulationVector popVec, boolean backup)	Implements equation (6) from Lam/Lien for combining two leaf node stations, more efficient than normal convolution if one is a fixed-rate station.
Thread	MultiThreadTCSolver.getComputeLeafNodeThread(Node node, PopulationVector pv)	Computes results at leaf node by creating an appropriate thread to run the computation.
protected ComplexityEvaluator.ComplexityBundle	TCComplexityEvaluator.getLeafNodeComplexity(Node n, PopulationVector popVec)	Gets the complexity of a leaf node computation in the tree convolution algorithm.
protected ComplexityEvaluator.ComplexityBundle	TCComplexityEvaluator.getStandardAlgorithmComplexity(PopulationVector popVec)	Gets the complexity of running standard convolution over a network with the specified population vector.
protected ComplexityEvaluator.ComplexityBundle	TCComplexityEvaluator.getSubnetNodeComplexity(Node n, PopulationVector popVec)	Gets the complexity of a subnetwork node computation in the tree convolution algorithm.
Thread	MultiThreadTCSolver.getSubnetNodeThread(Node node, PopulationVector pv)	Computes results at subnetwork node by creating an appropriate thread to run the computation.
void	SingleThreadTCSolver.initLeafNode(Node node, PopulationVector pv)	Computes results at leaf node by delegating to the convolution layer.
protected BigDecimal	ConvolutionCore.leafNodeDelayInitalCondition(PopulationVector p, PopulationVector popVec, Node n)	Computes the g-array at the specified leaf node representing a delay station.
boolean	TCComplexityEvaluator.treeHasAcceptableComplexity(Node root, PopulationVector pv)	Determines if the tree convolution algorithm for the specified tree has better complexity characteristics than the standard/sequential algorithm for the same network.