Merge branch 'master' into add-extend

Conflicts:
	lib/Fhaculty/Graph/Graph.php

Author: clue

CHANGELOG.md

@@ -6,9 +6,46 @@ you spot any mistakes.
 
 ## 0.8.0 (2013-xx-xx)
 
+*   BC break: Rename `Algorithm\Directed::isDirected()` to remove its ambiguity
+    in regards to mixed and/or empty graphs
+    ([#80](https://github.com/clue/graph/issues/80))
+
+    | Old name | New name |
+    |---|---|
+    | `Algorithm\Directed::isDirected()` | `Algorithm\Directed::hasDirected()` |
+
+*   Feature:: Add new `Algorithm\Directed::hasUndirected()` and
+    `Algorithm\Directed::isMixed()` in order to complement the renamed
+    `Algorithm\Directed::hasDirected()`
+    ([#80](https://github.com/clue/graph/issues/80))
+
+*   BC break: `Walk::factoryCycleFromVertices()` no longer tries to auto-complete
+    a cycle if the first vertex does not match the last one, but now throws an
+    `InvalidArgumentException` instead ([#87](https://github.com/clue/graph/issues/87)
+
+*   Feature: Support loop `Walk`s, i.e. a walk with only a single edge from
+    vertex A back to A ([#87](https://github.com/clue/graph/issues/87)
+
+*   Fix: Stricter checks for invalid cycles, such as one with an invalid
+    predecessor-map or no edges at all ([#87](https://github.com/clue/graph/issues/87)
+
+*   Fix: The `Algorithm\ShortestPath\MooreBellmanFord` now also works for unweighted
+    edges. This also fixes an issue where `Algorithm\DetectNegativeCycle` didn't work
+    for unweighted edges. ([#81](https://github.com/clue/graph/issues/81)
+
 *   Fix: Throwing an `UnexpectedValueException` if writing GraphViz Dot script
     to a temporary file fails and remove its debugging output
     ([#77](https://github.com/clue/graph/issues/77) and [#78](https://github.com/clue/graph/issues/78) @Metabor)
+    
+*   BC break: Remove unneeded alias definitions of `getVertexFirst()`,
+    `getVertexSource()` and `getVertexTarget()`
+    [#76]https://github.com/clue/graph/issues/76)):
+
+    | Old name | New name |
+    |---|---|
+    | `Graph::getVertexFirst()` | `Graph::getVertices()->getVertexFirst()` |
+    | `Walk::getVertexSource()` | `Walk::getVertices()->getVertexFirst()` |
+    | `Walk::getVertexTarget()` | `Walk::getVertices()->getVertexLast()` |
 
 ## 0.7.0 (2013-09-11)
 

lib/Fhaculty/Graph/Algorithm/ConnectedComponents.php

@@ -70,7 +70,7 @@ private function createSearch(Vertex $vertex)
     public function isSingle()
     {
         try {
-            $vertex = $this->graph->getVertexFirst();
+            $vertex = $this->graph->getVertices()->getVertexFirst();
         }
         catch (UnderflowException $e) {
             // no first vertex => empty graph => has zero components

lib/Fhaculty/Graph/Algorithm/Degree.php

@@ -31,7 +31,7 @@ class Degree extends BaseGraph
     public function getDegree()
     {
         // get initial degree of any start vertex to compare others to
-        $degree = $this->getDegreeVertex($this->graph->getVertexFirst());
+        $degree = $this->getDegreeVertex($this->graph->getVertices()->getVertexFirst());
 
         foreach ($this->graph->getVertices() as $vertex) {
             /** @var $vertex Vertex */

lib/Fhaculty/Graph/Algorithm/Directed.php

@@ -4,6 +4,7 @@
 
 use Fhaculty\Graph\Algorithm\BaseGraph;
 use Fhaculty\Graph\Edge\Directed as EdgeDirected;
+use Fhaculty\Graph\Edge\Undirected as EdgeUndirected;
 
 /**
  * Basic algorithms for working with the undirected or directed Graphs (digraphs) / Walks.
@@ -14,11 +15,14 @@
 class Directed extends BaseDual
 {
     /**
-     * checks whether the graph has any directed edges (aka digraph)
+     * checks whether the graph has any directed edges
+     *
+     * This method is intentionally not named "isDirected()" (aka digraph),
+     * because that might be misleading in regards to empty and/or mixed graphs.
      *
      * @return boolean
      */
-    public function isDirected()
+    public function hasDirected()
     {
         foreach ($this->set->getEdges() as $edge) {
             if ($edge instanceof EdgeDirected) {
@@ -28,4 +32,35 @@ public function isDirected()
 
         return false;
     }
+
+    /**
+     * checks whether the graph has any undirected edges
+     *
+     * This method is intentionally not named "isUndirected()",
+     * because that might be misleading in regards to empty and/or mixed graphs.
+     *
+     * @return boolean
+     */
+    public function hasUndirected()
+    {
+        foreach ($this->set->getEdges() as $edge) {
+            if ($edge instanceof EdgeUndirected) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * checks whether this is a mixed graph (contains both directed and undirected edges)
+     *
+     * @return boolean
+     * @uses self::hasDirected()
+     * @uses self::hasUndirected()
+     */
+    public function isMixed()
+    {
+        return ($this->hasDirected() && $this->hasUndirected());
+    }
 }

lib/Fhaculty/Graph/Algorithm/MaximumMatching/Flow.php

@@ -18,7 +18,7 @@ class Flow extends Base
     public function getEdges()
     {
         $alg = new Directed($this->graph);
-        if ($alg->isDirected()) {
+        if ($alg->hasDirected()) {
             throw new UnexpectedValueException('Input graph contains directed edges');
         }
 

lib/Fhaculty/Graph/Algorithm/ShortestPath/MooreBellmanFord.php

@@ -43,7 +43,7 @@ private function bigStep(Edges $edges, array &$totalCostOfCheapestPathTo, array
                     // New possible costs of this path
                     $newCost = $totalCostOfCheapestPathTo[$fromVertex->getId()] + $edge->getWeight();
                     if (is_infinite($newCost)) {
-                        $newCost = $edge->getWeight();
+                        $newCost = $edge->getWeight() + 0;
                     }
 
                     // No path has been found yet

lib/Fhaculty/Graph/Algorithm/TravelingSalesmanProblem/Bruteforce.php

@@ -92,7 +92,8 @@ public function setUpperLimitMst()
 
     protected function getVertexStart()
     {
-        return $this->graph->getVertexFirst();
+        // actual start doesn't really matter as we're only considering complete graphs here
+        return $this->graph->getVertices()->getVertexFirst();
     }
 
     protected function getGraph()
@@ -116,8 +117,7 @@ public function getEdges()
         // numEdges 3-12 should work
 
         $this->bestWeight = $this->upperLimit;
-        // actual start doesn't really matter as we're only considering complete graphs here
-        $this->startVertex = $this->graph->getVertexFirst();
+        $this->startVertex = $this->getVertexStart();
 
         $result = $this->step($this->startVertex,
                               0,

lib/Fhaculty/Graph/Algorithm/TravelingSalesmanProblem/MinimumSpanningTree.php

@@ -23,7 +23,7 @@ public function __construct(Graph $inputGraph)
 
     protected function getVertexStart()
     {
-        return $this->graph->getVertexFirst();
+        return $this->graph->getVertices()->getVertexFirst();
     }
 
     protected function getGraph()
@@ -43,7 +43,7 @@ public function getEdges()
         $minimumSpanningTreeAlgorithm = new MstKruskal($this->graph);
         $minimumSpanningTree = $minimumSpanningTreeAlgorithm->createGraph();
 
-        $alg = new SearchDepthFirst($minimumSpanningTree->getVertexFirst());
+        $alg = new SearchDepthFirst($minimumSpanningTree->getVertices()->getVertexFirst());
         // Depth first search in minmum spanning tree (for the eulerian path)
 
         $startVertex = NULL;

lib/Fhaculty/Graph/Algorithm/Tree/Undirected.php

@@ -50,7 +50,7 @@ class Undirected extends Tree
      *
      * @return boolean
      * @uses Vertices::isEmpty() to skip null Graphs (a Graph with no Vertices is *NOT* a valid tree)
-     * @uses Graph::getVertexFirst() to get get get random "root" Vertex to start search from
+     * @uses Vertices::getVertexFirst() to get get get random "root" Vertex to start search from
      * @uses self::getVerticesSubtreeRecursive() to count number of vertices connected to root
      */
     public function isTree()
@@ -60,7 +60,7 @@ public function isTree()
         }
 
         // every vertex can represent a root vertex, so just pick one
-        $root = $this->graph->getVertexFirst();
+        $root = $this->graph->getVertices()->getVertexFirst();
 
         $vertices = array();
         try {

lib/Fhaculty/Graph/Graph.php

@@ -324,23 +324,6 @@ public function hasVertex($id)
         return $this->vertices->hasVertexId($id);
     }
 
-    /**
-     * return first vertex found
-     *
-     * some algorithms do not need a particular vertex, but merely a (random)
-     * starting point. this is a convenience function to just pick the first
-     * vertex from the list of known vertices.
-     *
-     * @return Vertex             first vertex found in this graph
-     * @throws UnderflowException if Graph has no vertices
-     * @see Vertices::getVertexOrder() if you need to apply ordering first
-     * @uses Vertices::getVertexFirst()
-     */
-    public function getVertexFirst()
-    {
-        return $this->vertices->getVertexFirst();
-    }
-
     /**
      * adds a new Vertex to the Graph (MUST NOT be called manually!)
      *