Uses of Class
solvers.queueingnet.treeAlgorithms.Node

Packages that use Node

Package	Description
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 Node in solvers.queueingnet.treeAlgorithms

Fields in solvers.queueingnet.treeAlgorithms declared as Node

Modifier and Type	Field	Description
protected Node	Node.leftChild	This node's left child.
protected Node	Node.parent	This node's parent node.
protected Node	Node.rightChild	This node's right child.

Methods in solvers.queueingnet.treeAlgorithms that return Node

Modifier and Type	Method	Description
Node	Node.clone()	Creates a clone of this node.
Node	TreePlanter.createTreeWithClonedStation(int m)	Creates a copy of the current tree with station m cloned as an additional leaf node.
Node	TreePlanter.createTreeWithRemovedStation(int m)	Creates a copy of the current tree with the node for station m removed.
Node	Node.leftChild()	Returns the left child node.
Node	Node.merge(Node s)	Merges this node with another node by combining the stations.
Node	Node.parent()	Returns the parent node.
Node	Node.rightChild()	Returns the right child node.
Node	TreePlanter.rootClone()	Creates and returns a clone of the planted tree's root node.
Node	TreePlanter.treeRoot()	Gets the planted tree's root node.

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

Modifier and Type	Method	Description
protected double	ComplexityEvaluator.calculateFcsToPcsRatio(Node root)	Gets the ratio of fully covered classes to partially covered classes in the network.
protected int	ComplexityEvaluator.calculateNumberOfPcs(Node root)
int	ClassCoverageUtils.calculateSubnetWeight(Node n)	Calculates the weight of a subnetwork by implementing equation (10) from the LamLien83 paper.
abstract void	TreeTraverser.computeSubnetNode(Node node, PopulationVector pv)	Abstract method which an extending class will override to define subnetwork node computations.
abstract Thread	TreeTraverserMulti.getComputeLeafNodeThread(Node node, PopulationVector pv)	Abstract method which an extending class will override to define leaf node computations.
protected abstract ComplexityEvaluator.ComplexityBundle	ComplexityEvaluator.getLeafNodeComplexity(Node node, PopulationVector pv)	Gets the complexity of a leaf node computation in the tree algorithm.
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.
Node	Node.merge(Node s)	Merges this node with another node by combining the stations.
<T extends Comparable<?>> void	TreePrinter.printNode(Node root)	Prints the specified node and then its children recursively.
void	TreePlanter.printTree(Node root)	Prints a tree from specific root node.
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.setLeftChild(Node leftChild)	Sets the left child node.
void	Node.setParent(Node parent)	Sets this parent.
void	Node.setRightChild(Node rightChild)	Sets the right child node.
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 Node in solvers.queueingnet.treeAlgorithms.tmva

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

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.
void	TMVACore.computeSubnetNode(Node ab)	Computes the TMVA results at a subnet node.
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.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.
void	TMVACore.initLeafNode(Node node)	Initialises the specified leaf node, using the formulas in Hoyme's paper.
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 Node in solvers.queueingnet.treeAlgorithms.treeConvolution

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

Modifier and Type	Method	Description
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.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.