Home >> All >> com >> phoenixst

•	com.phoenixst.junit.* (1)	•	com.phoenixst.plexus.* (55)
•	com.phoenixst.plexus.examples.* (28)	•	com.phoenixst.plexus.operations.* (2)

Package Samples:

• com.phoenixst.plexus.operations: Contains the core interfaces and classes for the Plexus Graph Library.  
• com.phoenixst.plexus.examples
• com.phoenixst.plexus
• com.phoenixst.junit

Classes:

• DefaultGraph: A default implementation of the ObservableGraph interface. Design Criteria There are many ways of representing graphs in software, and this package uses just one of those for the general implementation. Of the two most basic, adjacency list and adjacency matrix, adjacency list is the most efficient for even remotely sparse graphs. Also, the design constraint that nodes and edges are user-provided objects would have made an adjacency matrix representation much more costly in terms of space (a HashMap would be required to map nodes to indices). In general, it seems preferable to implement a graph ...
• AbstractGraph: This class provides a skeletal implementation of the Graph interface, to minimize the effort required to implement this interface. Which methods must be implemented by a concrete extension of this class depends upon what kind of graph is being created. The programmer must provide implementations for the following methods (check all categories that apply): All Graph.nodeIterator() 55 Graph.edgeIterator() 55 Directed outTraverser( node ) 55 inTraverser( node ) 55 Undirected isDirected() 55 traverser( node ) 55 Simple isSimple() 55 removeEdge( Edge ) 55 getEdge( tail, head ) 55 Multi edgeIterator( ...
• Traverser: An interface for traversing through nodes in a Graph . An edge is followed to reach every visited node, or at least most of them. For example, the start node of a breadth first search is not reached through an edge. The hasNext() 55 method is not consistent with that defined by java.util.Iterator . Since remove() 55 will generally also remove a number of edges as a side-effect, hasNext() may return true before a call to remove() , but return false afterwards. Since the idiom is to call hasNext() just before calling next() , this is not normally an issue. Note that a traverser does not necessarily ...
• Graph: The root interface of the graph hierarchy. See the Overview Summary for details not included here. Nodes must contain unique (using Object.equals() 55 ) user-provided objects. This requirement allows nodes to be referenced unambiguously (when creating edges, for example). The user-defined objects contained in Graph.Edge objects, however, are not subject to this requirement in the general case, although Object.equals() will be used for edge comparisons. Nothing in this interface prohibits a Graph.Edge from also being a node in the same Graph . In other words, Edges can point to other Edges . If ...
• IntegerNodeGraph: An unmodifiable graph where the nodes are Integers from zero to a specified number (exclusive) and the edges do not contain user-defined objects. This is mainly useful for implementing special-case graphs that do not actually need to explicitly store their structure. By default, this implementation is undirected and simple. To fully implement an undirected simple extension of this class, the programmer must provide implementations for the following methods: getEdge( tail, head ) 55 edgeIterator() 55 traverser( node ) 55 In addition, it is recommended that the programmer override the following methods ...
• TraverserFactory: An interface used to encapsulate a particular type of Traverser , so that it may be used without knowledge of its implementation. See java.util.Comparator for a similar, but simpler, information hiding construct used in ordering collections. This allows graph algorithms to not have different implementations for undirected, forward directed, and reverse directed traversals, for example. The user may also create custom TraverserFactory objects to be used in non-trivial traversals. As an example, a graph representing a system of roads may be traversed by only following four-lane highways (a particular ...
• DefaultSimpleEdge: A default Graph.Edge implementation for a simple graph in which the user-defined object must be null . This class should only be used by Graphs which create edges lazily on demand. Otherwise, use DefaultEdge or DefaultObjectEdge instead. Reference equality is not used by equals( Object ) 55 .
• Product: A Graph which is the product of two other Graphs . The nodes are immutable java.util.List objects with exactly two elements, the first element being a node from the first graph and the second being a node from the second graph. Note: At the present time, only undirected simple graphs may be used. If either wrapped Graph contains Edges which point to other Edges , the product will not reflect this. The node and edge aspects of any such Edge will be distinct in the product.
• ObservableGraphWrapper: A wrapper around a Graph so that it can be watched for structural changes. Note: the Iterator.remove() > Iterator.remove() 55 method on Traversers created by this class will only work if the Traversers created by the wrapped Graph can tolerate having edges removed while the traversal is in progress.
• DefaultEdge: A default Graph.Edge implementation in which the user-defined object must be null . The equals() 55 method is inherited from Object and uses reference equality. This class should only be used by Graphs which create edges once and store them.
• DefaultObjectEdge: A default Graph.Edge implementation. The equals() 55 method is inherited from Object and uses reference equality. This class should only be used by Graphs which create edges once and store them.
• SimpleObjectEdge: A SimpleEdge which can contain a user-defined object. Because of how equals( Object ) 55 is defined, instances of this class may only be used by multigraphs when the endpoints and contained user-defined object are sufficient to distinguish distinct edges.
• Join: A Graph which is the join of two other Graphs with disjoint node sets. Note: At the present time, only undirected simple graphs may be used. The new edges added to the the union of the two graphs are effectively undirected edges. These new edges never contain user-defined objects.
• SimpleEdge: A simple Edge implementation which contains no user-defined object. Because of how equals( Object ) 55 is defined, instances of this class may only be used by simple graphs.
• NoSuchNodeException: Thrown by a Graph method when an argument node is not found in the Graph , but the method cannot provide a meaningful result or perform its function without one.
• Prism: An m x n prism, where m is the size of the cycle and n is the size of the path. This graph is pretty much a cylinder, but takes its name from the fact that if the cycle is of size 3, then it looks like a prism.
• NodeOffsetTransformer: A com.phoenixst.plexus.Graph which wraps another, adding the specified offset to the underlying graph's nodes, which must be Integers .
• StaticGraphTest: A Graph tester which uses a single static graph, mostly for ease of use when testing with beanshell.
• Cycle: A Graph containing a set of Integer nodes connected by a path of edges from the first node to the last one, and then back to the first, making a cycle.
• CloneableTestCase: A TestCase for which instances are Cloneable . This class has been copied from the test code in the Melange project (http://melange.sourceforge.net).
• DefaultGraphExamplesTest: A com.phoenixst.plexus.DefaultGraph tester for copies of examples graphs, at least the immutable operations.
• CompleteBipartiteGraphTest: A CompleteBipartiteGraph tester.
• Weight: A weight function, which may be applied to Graph.Edge s.

Home | Contact Us | Privacy Policy | Terms of Service