Package Opus5

Interface Summary

Comparable	Encapsulates methods for comparing objects.
Container	Encapsulates methods common to all container classes.
Cursor	Used to represent a position in an ordered list or a sorted list.
Deque	Encapsulates methods common to all deques (double-ended queues).
Digraph	Encapsulates methods common to all directed graph.
DoubleEndedPriorityQueue	Encapsulates methods common to all double-ended priority queues.
Edge	Encapsulates methods common to all graph edges.
Enumeration	Encapsulates methods common to all enumerations.
Graph	Encapsulates methods common to all graphs (both directed and undirected).
GraphicsPrimitives	Encapsulates a simple set of primitive operations on graphical objects.
HashTable	Encapsulates methods common to all hash tables.
Matrix	Encapsulates methods for manipulating a two-dimensional matrix of doubles.
MergeablePriorityQueue	Encapsulates methods common to all mergeable priority queues.
Multiset	Encapsulates methods common to all multisets.
OrderedList	Encapsulates methods common to all ordered lists.
Partition	Encapsulates methods common to all partitions.
Polynomial	Encapsulates methods common to all polynomials.
PrePostVisitor	Encapsulates methods implemented by visitors used in conjunction with various depth-first traversal methods.
PriorityQueue	Encapsulates methods common to all priority queues.
Queue	Encapsulates methods common to all (single-ended, FIFO) queues.
RandomVariable	Encapsulates methods common to all random variables.
SearchableContainer	Encapsulates methods common to all searchable container classes.
SearchTree	Encapsulates methods common to all search trees.
Set	Encapsulates methods common to all sets.
Solution	Used to represent the nodes of the solution space of a problem.
Solver	A solver is an abstract machine that solves a problem by exploring its solution space.
SortedList	Encapsulates methods common to all sorted lists.
Sorter	A sorter is an abstract machine that sorts an array of comparable objects.
SparseMatrix	Encapsulates methods for manipulating a sparse, two-dimensional matrix of doubles.
Stack	Encapsulates methods common to all stacks.
Tree	Encapsulates methods common to the nodes of a tree.
Vertex	Encapsulates methods common to all graph vertices.
Visitor	Encapsulates methods implemented by visitors which are used in conjunction with containers as well as by various graph and tree traversal methods.

Class Summary

AbstractContainer	The AbstractContainer is the base class from which all concrete container classes are derived.
AbstractGraph	The AbstractGraph class is the base class from which all concrete undirected and directed graph classes are derived.
AbstractGraph.Counter	A counter object.
AbstractHashTable	The AbstractHashTable class is the base class from which all concrete hash and scatter table classes are derived.
AbstractObject	The AbstractObject class is the base class from which all concrete classes that implement the Comparable interface are derived.
AbstractPrePostVisitor	The AbstractPrePostVisitor class is the base class from which all concrete pre/post visitor classes are derived.
AbstractQuickSorter	The AbstractQuickSorter class is the base class from which all concrete quick sorter classes are derived.
AbstractSearchableContainer	The AbstractSearchableContainer class is the base class from which all concrete searchable container classes are derived.
AbstractSet	The AbstractSet class is the base class from which all concrete set and multiset classes are derived.
AbstractSolver	The AbstractSolver class is the base class from which all concrete solver classes are derived.
AbstractSorter	The AbstractSorter class is the base class from which all concrete sorter classes are derived.
AbstractTree	The AbstractTree class is the base class from which all concrete tree classes are derived.
AbstractVisitor	The AbstractVisitor class is the base class from which all concrete visitor classes are derived.
Algorithms	Various algorithms.
App
Application1	Application program that uses a stack to implement an RPN calculator.
Application11	Application program that demonstrates critical-path analysis.
Application12	Application program that demonstrates the use of various problem solvers to solve a scales-balancing problem and a 0/1-knapsack problem.
Application2	Application program that illustrates the use of a queue to implement breadth-first traversal.
Application3	Application program that illustrates the implemention of polynomials using ordered lists.
Application4	Application program that illustrates the implementation of polynomials as sorted lists.
Application5	Application program that illustrates the use of a hash table to count number of occurrences of each word in the input text.
Application6	Application program that illustrates the use of a binary tree to convert a postfix expression to an infix expression.
Application7	Application program the illustrates the use of a search tree to implement a word-by-word translation.
Application8	Application program that illustrates the use of a priority queue to implement a discrete-event simulation.
Application9	Application program that illustrates the use of a partition to compute equivalence classes.
Array	An array of Objects.
Association	An association is a (key, value) pair that implements the Comparable interface.
AVLTree	A node in an AVL tree.
BinaryHeap	A priority queue implemented as a binary heap.
BinaryInsertionSorter	Sorter for sorting an array of Comparable objects.
BinarySearchTree	A node in a binary search tree.
BinaryTree	A node in a binary tree.
BinomialQueue	A mergeable priority queue implemented as a forest of binomial trees.
BinomialQueue.BinomialTree	A node in a binomial tree.
Bounds	Provides one static method to simplify array-bounds checking.
BreadthFirstBranchAndBoundSolver	Branch-and-bound, breadth-first problem solver for searching tree-structures solution spaces.
BreadthFirstSolver	Breadth-first problem solver for searching tree-structured solution spaces.
BTree	A node in a B-tree.
BubbleSorter	Sorter for sorting an array of Comparable objects.
BucketSorter	Sorter for sorting an array of Ints.
ChainedHashTable	A chained hash table implemented using an array of linked lists.
ChainedScatterTable	A chained hash table implemented using an array.
ChainedScatterTable.Entry	Entry data structure
Chr	Wrapper class that wraps a char and implements the Comparable interface.
Circle	A circular graphical object.
Complex	A complex number.
Dbl	Wrapper class that wraps a double and implements the Comparable interface.
Deap	A double-ended priority queue implemented as a binary heap.
Demo1	Demonstration program that tests the following classes: DenseMatrix, SparseMatrixAsArray, SparseMatrixAsVector, and SparseMatrixAsLinkedList.
Demo10	Demonstration program that tests the following classes: GraphAsMatrix, GraphAsLists, DigraphAsMatrix, and DigraphAsLists.
Demo2	Demonstration program that tests the following classes: StackAsArray, StackAsLinkedList, QueueAsArray, QueueAsLinkedList, DequeAsArray, and DequeAsLinkedList.
Demo3	Demonstration program that tests the following classes: OrderedListAsArray, OrderedListAsLinkedList, SortedListAsArray, and SortedListAsLinkedList.
Demo4	Demonstration program that tests the following classes: ChainedHashTable, ChainedScatterTable, and OpenScatterTable.
Demo5	Demonstration program that tests the following classes: GeneralTree, BinaryTree, NaryTree, BinarySearchTree, AVLTree, MWayTree, and BTree.
Demo6	Demonstration program that tests the following classes: BinaryHeap, LeftistHeap, BinomialQueue, and Deap.
Demo7	Demonstration program that tests the following classes: SetAsArray, SetAsBitVector, MultisetAsArray, MultisetAsLinkedList, PartitionAsForest, PartitionAsForestV2, and PartitionAsForestV3.
Demo9	Demonstration program that tests the following classes: StraightInsertionSorter, BinaryInsertionSorter, StraightSelectionSorter, BubbleSorter, HeapSorter, MedianOfThreeQuickSorter, TwoWayMergeSorter, BucketSorter, and RadixSorter.
DenseMatrix	Dense matrix implemented using a two-dimensional array.
DepthFirstBranchAndBoundSolver	Depth-first, branch-and-bound problem solver for searching tree-structured solution spaces.
DepthFirstSolver	Depth-first problem solver for searching tree-structured solution spaces.
DequeAsArray	A deque (double-ended queue) implemented using an array.
DequeAsLinkedList	A deque (double-ended queue) implemented using a linked list.
DigraphAsLists	A directed graph implemented using adjacency lists.
DigraphAsMatrix	A directed graph implemented using an adjacency matrix.
Example	Various example methods.
Experiment2	Measures the running times of various sorters.
ExponentialRV	Exponentially distributed random variable.
ExpressionTree	Represents a binary expression as a binary tree.
GeneralTree	A node in a general tree.
GraphAsLists	An undirected graph implemented using adjacency lists.
GraphAsMatrix	An undirected graph implemented using an adjacency matrix.
GraphicalObject	The GraphicalObject class is the base class from which various concrete graphical object classes are derived.
HeapSorter	Sorter for sorting an array of Comparable objects.
InOrder	Adapter to convert a Visitor to a PrePostVisitor.
Int	Wrapper class that wraps an int and implements the Comparable interface.
LeftistHeap	A node of a mergeable priority queue implemented as a leftist tree.
LinkedList	A linear, singly-linked list of Objects.
Lng	Wrapper class that wraps a long and implements the Comparable interface.
MedianOfThreeQuickSorter	Sorter for sorting an array of Comparable objects.
MultiDimensionalArray	A multi-dimensional array of Objects implemented using a one-dimensional array.
MultisetAsArray	Multiset implemented using an array of ints.
MultisetAsLinkedList	Multiset implemented using a linked list.
MWayTree	A node in an M-way tree.
NaryTree	A node in an N-ary tree.
OpenScatterTable	Open scatter table implemented using an array.
OpenScatterTable.Entry	Entry data structure.
OpenScatterTableV2	Open scatter table implemented using an array.
OrderedListAsArray	An ordered list implemented using an array.
OrderedListAsLinkedList	An ordered list implemented using a linked list.
Parent	Records some basic information about a parent.
PartitionAsForest	A partition implemented as a forest of trees.
PartitionAsForestV2	A partition implemented as a forest of trees.
PartitionAsForestV3	A partition implemented as a forest of trees.
Person	Records some basic information about a person.
Point	Represents a point in the Cartesian plane.
PolynomialAsOrderedList	A polynomial implemented using an ordered list.
PolynomialAsSortedList	A polynomial implemented using a sorted list.
PostOrder	Adapter to convert a Visitor to a PrePostVisitor.
PreOrder	Adapter to convert a Visitor to a PrePostVisitor.
QueueAsArray	A queue implemented using an array.
QueueAsLinkedList	A queue implemented using a linked list.
RadixSorter	Sorter for sorting an array of Ints.
RandomNumberGenerator	A multiplicative linear congruential pseudo-random number generator.
Rectangle	A rectangular graphical object.
ScalesBalancingProblem	Represents a scales balancing problem.
SetAsArray	Set implemented using an array of booleans.
SetAsBitVector	Set implemented using a vector of ints.
SimpleRV	A random variable uniformly distributed on the unit interval, (0,1).
Simulation	A discrete-event simulation of an M/M/1 queue.
SortedListAsArray	A sorted list implemented using an array.
SortedListAsLinkedList	A sorted list implemented using an array.
SparseMatrixAsArray	Sparse matrix implemented using arrays.
SparseMatrixAsLinkedList	Sparse matrix implemented using an array of linked lists.
SparseMatrixAsVector	Sparse matrix implemented using a vector of triples.
Square	A square graphical object.
StackAsArray	A stack implemented using an array.
StackAsLinkedList	A stack implemented using a linked list.
Str	Wrapper class that wraps a String and implements the Comparable interface.
StraightInsertionSorter	Sorter for sorting an array of Comparable objects.
StraightSelectionSorter	Sorter for sorting an array of Comparable objects.
Term	A term in a polynomial.
Terminal
TTY
TwoWayMergeSorter	Sorter for sorting an array of Comparable objects.
UniformRV	A random variable uniformly distributed on a specified interval, (u,v).
ZeroOneKnapsackProblem	Represents a 0/1 knapsack problem.

Exception Summary

ContainerEmptyException	Thrown when an attempting to get an object from an empty container.
ContainerFullException	Thrown when attempty to put an object into a full container.
DomainException	Thrown by a method when it is called with an argument value (or values) for which it is not defined.
InvalidOperationException	Thrown when a method is invoked to perform an operation that is not permitted by the current state of this object.
MethodNotImplemented	Thrown by a method for which the code has not yet been written.