Automated native_function_invocation fixes

src/Bipartit.php

@@ -60,7 +60,7 @@ public function getColors()
                 // breadth search all vertices in same component
                 do {
                     // next vertex in color
-                    $vertex = array_shift($queue);
+                    $vertex = \array_shift($queue);
                     $color = $colors[$vertex->getId()];
                     $nextColor = 1-$color;
 

src/ConnectedComponents.php

@@ -78,7 +78,7 @@ public function isSingle()
         }
         $alg = $this->createSearch($vertex);
 
-        return (count($this->graph->getVertices()) === count($alg->getVertices()));
+        return (\count($this->graph->getVertices()) === \count($alg->getVertices()));
     }
 
     /**

src/Degree.php

@@ -164,7 +164,7 @@ public function isVertexSink(Vertex $vertex)
      */
     public function getDegreeVertex(Vertex $vertex)
     {
-        return count($vertex->getEdges());
+        return \count($vertex->getEdges());
     }
 
     /**

src/Groups.php

@@ -16,7 +16,7 @@ class Groups extends BaseGraph
      */
     public function getNumberOfGroups()
     {
-        return count($this->getGroups());
+        return \count($this->getGroups());
     }
 
     /**
@@ -63,7 +63,7 @@ public function getGroups()
             $groups[$vertex->getGroup()] = true;
         }
 
-        return array_keys($groups);
+        return \array_keys($groups);
     }
 
     /**

src/MaximumMatching/Base.php

@@ -18,7 +18,7 @@ abstract class Base extends BaseGraph
      */
     public function getNumberOfMatches()
     {
-        return count($this->getEdges());
+        return \count($this->getEdges());
     }
 
     /**

src/MinimumSpanningTree/Kruskal.php

@@ -103,7 +103,7 @@ public function getEdges()
                 $worseColor  = $bColor;
 
                 // more vertices with color a => paint all in b in a's color
-                if (count($colorVertices[$bColor]) > count($colorVertices[$aColor])) {
+                if (\count($colorVertices[$bColor]) > \count($colorVertices[$aColor])) {
                     $betterColor = $bColor;
                     $worseColor = $aColor;
                 }
@@ -125,7 +125,7 @@ public function getEdges()
 
         // definition of spanning tree: number of edges = number of vertices - 1
         // above algorithm does not check isolated edges or may otherwise return multiple connected components => force check
-        if (count($returnEdges) !== (count($this->graph->getVertices()) - 1)) {
+        if (\count($returnEdges) !== (\count($this->graph->getVertices()) - 1)) {
             throw new UnexpectedValueException('Graph is not connected');
         }
 

src/MinimumSpanningTree/Prim.php

@@ -35,7 +35,7 @@ public function getEdges()
         $returnEdges = array();
 
         // iterate n-1 times (per definition, resulting MST MUST have n-1 edges)
-        for ($i = 0, $n = count($this->startVertex->getGraph()->getVertices()) - 1; $i < $n; ++$i) {
+        for ($i = 0, $n = \count($this->startVertex->getGraph()->getVertices()) - 1; $i < $n; ++$i) {
             $markInserted[$vertexCurrent->getId()] = true;
 
             // get unvisited vertex of the edge and add edges from new vertex

src/Parallel.php

@@ -68,7 +68,7 @@ public function getEdgesParallelEdge(Edge $edge)
             $edges = $ends->getVertexFirst()->getEdges()->getEdgesIntersection($ends->getVertexLast()->getEdges())->getVector();
         }
 
-        $pos = array_search($edge, $edges, true);
+        $pos = \array_search($edge, $edges, true);
 
         if ($pos === false) {
             // @codeCoverageIgnoreStart
@@ -79,6 +79,6 @@ public function getEdgesParallelEdge(Edge $edge)
         // exclude current edge from parallel edges
         unset($edges[$pos]);
 
-        return new Edges(array_values($edges));
+        return new Edges(\array_values($edges));
     }
 }

src/Property/GraphProperty.php

@@ -46,6 +46,6 @@ public function isNull()
      */
     public function isTrivial()
     {
-        return ($this->graph->getEdges()->isEmpty() && count($this->graph->getVertices()) === 1);
+        return ($this->graph->getEdges()->isEmpty() && \count($this->graph->getVertices()) === 1);
     }
 }

src/Property/WalkProperty.php

@@ -162,7 +162,7 @@ public function hasCycle()
      */
     public function isLoop()
     {
-        return (count($this->walk->getEdges()) === 1 && $this->isCycle());
+        return (\count($this->walk->getEdges()) === 1 && $this->isCycle());
     }
 
     /**
@@ -214,11 +214,11 @@ public function hasLoop()
     public function isDigon()
     {
         // exactly 2 edges
-        return (count($this->walk->getEdges()) === 2 &&
+        return (\count($this->walk->getEdges()) === 2 &&
                 // no duplicate edges
                 !$this->hasArrayDuplicates($this->walk->getEdges()->getVector()) &&
                 // exactly two distinct vertices
-                count($this->walk->getVertices()->getVerticesDistinct()) === 2 &&
+                \count($this->walk->getVertices()->getVerticesDistinct()) === 2 &&
                 // this is actually a cycle
                 $this->isCycle());
     }
@@ -238,9 +238,9 @@ public function isDigon()
     public function isTriangle()
     {
         // exactly 3 (implicitly distinct) edges
-        return (count($this->walk->getEdges()) === 3 &&
+        return (\count($this->walk->getEdges()) === 3 &&
                 // exactly three distinct vertices
-                count($this->walk->getVertices()->getVerticesDistinct()) === 3 &&
+                \count($this->walk->getVertices()->getVerticesDistinct()) === 3 &&
                 // this is actually a cycle
                 $this->isCycle());
     }
@@ -347,7 +347,7 @@ private function hasArrayDuplicates($array)
         $compare = array();
         foreach ($array as $element) {
             // duplicate element found
-            if (in_array($element, $compare, true)) {
+            if (\in_array($element, $compare, true)) {
                 return true;
             } else {
                 // add element to temporary array to check for duplicates
@@ -368,7 +368,7 @@ private function hasArrayDuplicates($array)
     private function isArrayContentsEqual($a, $b)
     {
         foreach ($b as $one) {
-            $pos = array_search($one, $a, true);
+            $pos = \array_search($one, $a, true);
             if ($pos === false) {
                 return false;
             } else {

src/Search/BreadthFirst.php

@@ -27,7 +27,7 @@ public function getVertices($maxDepth = PHP_INT_MAX)
 
         do {
             // get first from queue
-            $t = array_shift($queue);
+            $t = \array_shift($queue);
             // save as visited
             $visited[$t->getId()] = $t;
 

src/Search/DepthFirst.php

@@ -15,11 +15,11 @@ public function getVertices()
     {
         $visited = array();
         $todo = array($this->vertex);
-        while ($vertex = array_shift($todo)) {
+        while ($vertex = \array_shift($todo)) {
             if (!isset($visited[$vertex->getId()])) {
                 $visited[$vertex->getId()] = $vertex;
 
-                foreach (array_reverse($this->getVerticesAdjacent($vertex)->getMap(), true) as $vid => $nextVertex) {
+                foreach (\array_reverse($this->getVerticesAdjacent($vertex)->getMap(), true) as $vid => $nextVertex) {
                     $todo[] = $nextVertex;
                 }
             }

src/ShortestPath/Base.php

@@ -111,7 +111,7 @@ protected function getEdgesToInternal(Vertex $endVertex, $edges)
             }
         } while ($currentVertex !== $this->vertex);
 
-        return new Edges(array_reverse($path));
+        return new Edges(\array_reverse($path));
     }
 
     /**

src/ShortestPath/BreadthFirst.php

@@ -32,7 +32,7 @@ class BreadthFirst extends Base
      */
     public function getDistance(Vertex $endVertex)
     {
-        return count($this->getEdgesTo($endVertex));
+        return \count($this->getEdgesTo($endVertex));
     }
 
     /**
@@ -56,12 +56,12 @@ public function getEdgesMap()
                 $vid = $vertexTarget->getId();
                 if (!isset($edges[$vid])) {
                     $vertexQueue []= $vertexTarget;
-                    $edges[$vid] = array_merge($edgesCurrent, array($edge));
+                    $edges[$vid] = \array_merge($edgesCurrent, array($edge));
                 }
             }
 
             // get next from queue
-            $vertexCurrent = array_shift($vertexQueue);
+            $vertexCurrent = \array_shift($vertexQueue);
             if ($vertexCurrent) {
                 $edgesCurrent = $edges[$vertexCurrent->getId()];
             }
@@ -93,7 +93,7 @@ public function getDistanceMap()
     {
         $ret = array();
         foreach ($this->getEdgesMap() as $vid => $edges) {
-            $ret[$vid] = count($edges);
+            $ret[$vid] = \count($edges);
         }
 
         return $ret;
@@ -121,7 +121,7 @@ public function getEdges()
         $ret = array();
         foreach ($this->getEdgesMap() as $edges) {
             foreach ($edges as $edge) {
-                if (!in_array($edge, $ret, true)) {
+                if (!\in_array($edge, $ret, true)) {
                     $ret []= $edge;
                 }
             }

src/ShortestPath/Dijkstra.php

@@ -46,7 +46,7 @@ public function getEdges()
         $isFirst = true;
 
         // Repeat until all vertices have been marked
-        $totalCountOfVertices = count($this->vertex->getGraph()->getVertices());
+        $totalCountOfVertices = \count($this->vertex->getGraph()->getVertices());
         for ($i = 0; $i < $totalCountOfVertices; ++$i) {
             $currentVertex = NULL;
             $currentVertexId = NULL;
@@ -89,7 +89,7 @@ public function getEdges()
                 if (!isset($usedVertices[$targetVertexId])) {
                     // calculate new cost to vertex
                     $newCostsToTargetVertex = $totalCostOfCheapestPathTo[$currentVertexId] + $weight;
-                    if (is_infinite($newCostsToTargetVertex)) {
+                    if (\is_infinite($newCostsToTargetVertex)) {
                         $newCostsToTargetVertex = $weight;
                     }
 

src/ShortestPath/MooreBellmanFord.php

@@ -42,7 +42,7 @@ private function bigStep(Edges $edges, array &$totalCostOfCheapestPathTo, array
                 if (isset($totalCostOfCheapestPathTo[$fromVertex->getId()])) {
                     // New possible costs of this path
                     $newCost = $totalCostOfCheapestPathTo[$fromVertex->getId()] + $edge->getWeight();
-                    if (is_infinite($newCost)) {
+                    if (\is_infinite($newCost)) {
                         $newCost = $edge->getWeight() + 0;
                     }
 
@@ -79,7 +79,7 @@ public function getEdges()
         // the usal algorithm says we repeat (n-1) times.
         // but because we also want to check for loop edges on the start vertex,
         // we have to add an additional step:
-        $numSteps = count($this->vertex->getGraph()->getVertices());
+        $numSteps = \count($this->vertex->getGraph()->getVertices());
         $edges = $this->vertex->getGraph()->getEdges();
         $changed = true;
 

src/TopologicalSort.php

@@ -32,27 +32,27 @@ public function getVertices()
         /** @var Vertex $top */
         // TODO: avoid having to reverse all vertices multiple times
         // pick a node to examine next - assume there are isolated nodes
-        foreach (array_reverse($this->graph->getVertices()->getVector()) as $top) {
+        foreach (\array_reverse($this->graph->getVertices()->getVector()) as $top) {
             $tid = $top->getId();
             if (!isset($visited[$tid])) { // don't examine if already found
-                array_push($stack, $top);
+                \array_push($stack, $top);
             }
 
             while ($stack) {
                 /** @var Vertex $current */
-                $node = end($stack);
+                $node = \end($stack);
                 $nid = $node->getId();
 
                 $visited[$nid] = false; // temporary mark
                 $found = false; // new children found during visit to this node
 
                 // find the next node to visit
                 /** @var Vertex $child */
-                foreach (array_reverse($node->getVerticesEdgeTo()->getVector()) as $child) {
+                foreach (\array_reverse($node->getVerticesEdgeTo()->getVector()) as $child) {
                     $cid = $child->getId();
                     if (!isset($visited[$cid])) {
                         // found a new node - push it onto the stack
-                        array_push($stack, $child);
+                        \array_push($stack, $child);
                         $found = true; // move onto the new node
                         break;
                     } else if ($visited[$cid] === false) {
@@ -62,13 +62,13 @@ public function getVertices()
                 }
 
                 if (!$found) {
-                    array_pop($stack); // no new children found - we're done with this node
+                    \array_pop($stack); // no new children found - we're done with this node
                     $visited[$nid] = true; // mark as visited
-                    array_push($output, $node); // add to results
+                    \array_push($output, $node); // add to results
                 }
             }
         }
 
-        return new Vertices(array_reverse($output, true));
+        return new Vertices(\array_reverse($output, true));
     }
 }

src/TravelingSalesmanProblem/Bruteforce.php

@@ -114,7 +114,7 @@ protected function getGraph()
      */
     public function getEdges()
     {
-        $this->numEdges = count($this->graph->getVertices());
+        $this->numEdges = \count($this->graph->getVertices());
         if ($this->numEdges < 3) {
             throw new UnderflowException('Needs at least 3 vertices');
         }
@@ -152,7 +152,7 @@ private function step(Vertex $vertex, $totalWeight, array $visitedVertices, arra
             return NULL;
         }
         // kreis geschlossen am Ende
-        if ($vertex === $this->startVertex && count($visitedEdges) === $this->numEdges) {
+        if ($vertex === $this->startVertex && \count($visitedEdges) === $this->numEdges) {
             // new best result
             $this->bestWeight = $totalWeight;
 
@@ -180,7 +180,7 @@ private function step(Vertex $vertex, $totalWeight, array $visitedVertices, arra
             $result = $this->step($target,
                                   $totalWeight + $weight,
                                   $visitedVertices,
-                                  array_merge($visitedEdges, array($edge))
+                                  \array_merge($visitedEdges, array($edge))
                       );
 
             // new result found

src/TravelingSalesmanProblem/NearestNeighbor.php

@@ -40,7 +40,7 @@ public function getEdges()
     {
         $returnEdges = array();
 
-        $n = count($this->vertex->getGraph()->getVertices());
+        $n = \count($this->vertex->getGraph()->getVertices());
 
         $vertex = $this->vertex;
         $visitedVertices = array($vertex->getId() => true);