php-ai / php-ml

src/Phpml/Math/Matrix.php

Doc Comments +2 added lines, -2 removed lines

@@ -106,7 +106,7 @@ 
     }
 
     /**
-     * @param $column
+     * @param integer $column
      *
      * @return array
      *
@@ -278,7 +278,7 @@ 
      * Element-wise addition or substraction depending on the given sign parameter
      *
      * @param Matrix $other
-     * @param type $sign
+     * @param integer $sign
      */
     protected function _add(Matrix $other, $sign = 1)
     {

Spacing +4 added lines, -4 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace Phpml\Math;
 
@@ -179,7 +179,7 @@ 
     public function transpose()
     {
         if ($this->rows == 1) {
-            $matrix = array_map(function ($el) {
+            $matrix = array_map(function($el) {
                 return [$el];
             }, $this->matrix[0]);
         } else {
@@ -283,8 +283,8 @@ 
         $a2 = $other->toArray();
 
         $newMatrix = [];
-        for ($i=0; $i < $this->rows; $i++) {
-            for ($k=0; $k < $this->columns; $k++) {
+        for ($i = 0; $i < $this->rows; $i++) {
+            for ($k = 0; $k < $this->columns; $k++) {
                 $newMatrix[$i][$k] = $a1[$i][$k] + $sign * $a2[$i][$k];
             }
         }

src/Phpml/Math/Statistic/Covariance.php

Doc Comments -1 removed lines

@@ -60,7 +60,6 @@
      * @param int $i
      * @param int $k
      * @param type $sample
-     * @param int $n
      * @param float $meanX
      * @param float $meanY
      */

Spacing +4 added lines, -4 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace Phpml\Math\Statistic;
 
@@ -133,14 +133,14 @@ 
 
         if ($means === null) {
             $means = [];
-            for ($i=0; $i < $n; $i++) {
+            for ($i = 0; $i < $n; $i++) {
                 $means[] = Mean::arithmetic(array_column($data, $i));
             }
         }
 
         $cov = [];
-        for ($i=0; $i < $n; $i++) {
-            for ($k=0; $k < $n; $k++) {
+        for ($i = 0; $i < $n; $i++) {
+            for ($k = 0; $k < $n; $k++) {
                 if ($i > $k) {
                     $cov[$i][$k] = $cov[$k][$i];
                 } else {

src/Phpml/DimensionReduction/KernelPCA.php

Indentation +3 added lines, -3 removed lines

@@ -136,9 +136,9 @@
         $N_K_N = $N->multiply($K_N);
 
         return $K->subtract($N_K)
-                 ->subtract($K_N)
-                 ->add($N_K_N)
-                 ->toArray();
+                    ->subtract($K_N)
+                    ->add($N_K_N)
+                    ->toArray();
     }
 
     /**

Spacing +10 added lines, -10 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace Phpml\DimensionReduction;
 
@@ -48,7 +48,7 @@ 
     public function __construct(int $kernel = self::KERNEL_RBF, $totalVariance = null, $numFeatures = null, $gamma = null)
     {
         $availableKernels = [self::KERNEL_RBF, self::KERNEL_SIGMOID, self::KERNEL_LAPLACIAN, self::KERNEL_LINEAR];
-        if (! in_array($kernel, $availableKernels)) {
+        if (!in_array($kernel, $availableKernels)) {
             throw new \Exception("KernelPCA can be initialized with the following kernels only: Linear, RBF, Sigmoid and Laplacian");
         }
 
@@ -102,8 +102,8 @@ 
         $kernelFunc = $this->getKernel();
 
         $matrix = [];
-        for ($i=0; $i < $numRows; $i++) {
-            for ($k=0; $k < $numRows; $k++) {
+        for ($i = 0; $i < $numRows; $i++) {
+            for ($k = 0; $k < $numRows; $k++) {
                 if ($i <= $k) {
                     $matrix[$i][$k] = $kernelFunc($data[$i], $data[$k]);
                 } else {
@@ -126,7 +126,7 @@ 
      */
     protected function centerMatrix(array $matrix, int $n)
     {
-        $N = array_fill(0, $n, array_fill(0, $n, 1.0/$n));
+        $N = array_fill(0, $n, array_fill(0, $n, 1.0 / $n));
         $N = new Matrix($N, false);
         $K = new Matrix($matrix, false);
 
@@ -153,19 +153,19 @@ 
         switch ($this->kernel) {
             case self::KERNEL_LINEAR:
                 // k(x,y) = xT.y
-                return function ($x, $y) {
+                return function($x, $y) {
                     return Matrix::dot($x, $y)[0];
                 };
             case self::KERNEL_RBF:
                 // k(x,y)=exp(-γ.|x-y|) where |..| is Euclidean distance
                 $dist = new Euclidean();
-                return function ($x, $y) use ($dist) {
+                return function($x, $y) use ($dist) {
                     return exp(-$this->gamma * $dist->sqDistance($x, $y));
                 };
 
             case self::KERNEL_SIGMOID:
                 // k(x,y)=tanh(γ.xT.y+c0) where c0=1
-                return function ($x, $y) {
+                return function($x, $y) {
                     $res = Matrix::dot($x, $y)[0] + 1.0;
                     return tanh($this->gamma * $res);
                 };
@@ -173,7 +173,7 @@ 
             case self::KERNEL_LAPLACIAN:
                 // k(x,y)=exp(-γ.|x-y|) where |..| is Manhattan distance
                 $dist = new Manhattan();
-                return function ($x, $y) use ($dist) {
+                return function($x, $y) use ($dist) {
                     return exp(-$this->gamma * $dist->distance($x, $y));
                 };
         }
@@ -204,7 +204,7 @@ 
     protected function projectSample(array $pairs)
     {
         // Normalize eigenvectors by eig = eigVectors / eigValues
-        $func = function ($eigVal, $eigVect) {
+        $func = function($eigVal, $eigVect) {
             $m = new Matrix($eigVect, false);
             $a = $m->divideByScalar($eigVal)->toArray();
 

src/Phpml/DimensionReduction/PCA.php

Spacing +5 added lines, -5 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace Phpml\DimensionReduction;
 
@@ -115,7 +115,7 @@ 
     {
         // Calculate means for each dimension
         $this->means = [];
-        for ($i=0; $i < $n; $i++) {
+        for ($i = 0; $i < $n; $i++) {
             $column = array_column($data, $i);
             $this->means[] = Mean::arithmetic($column);
         }
@@ -138,7 +138,7 @@ 
 
         // Normalize data
         foreach ($data as $i => $row) {
-            for ($k=0; $k < $n; $k++) {
+            for ($k = 0; $k < $n; $k++) {
                 $data[$i][$k] -= $this->means[$k];
             }
         }
@@ -160,7 +160,7 @@ 
     {
         $eig = new EigenvalueDecomposition($matrix);
         $eigVals = $eig->getRealEigenvalues();
-        $eigVects= $eig->getEigenvectors();
+        $eigVects = $eig->getEigenvectors();
 
         $totalEigVal = array_sum($eigVals);
         // Sort eigenvalues in descending order
@@ -217,7 +217,7 @@ 
             throw new \Exception("PCA has not been fitted with respect to original dataset, please run PCA::fit() first");
         }
 
-        if (! is_array($sample[0])) {
+        if (!is_array($sample[0])) {
             $sample = [$sample];
         }
 

src/Phpml/Math/LinearAlgebra/EigenvalueDecomposition.php

Indentation +9 added lines, -9 removed lines

@@ -58,21 +58,21 @@
     private $V = [];
 
     /**
-    *	Array for internal storage of nonsymmetric Hessenberg form.
-    *	@var array
-    */
+     *	Array for internal storage of nonsymmetric Hessenberg form.
+     *	@var array
+     */
     private $H = [];
 
     /**
-    *	Working storage for nonsymmetric algorithm.
-    *	@var array
-    */
+     *	Working storage for nonsymmetric algorithm.
+     *	@var array
+     */
     private $ort;
 
     /**
-    *	Used for complex scalar division.
-    *	@var float
-    */
+     *	Used for complex scalar division.
+     *	@var float
+     */
     private $cdivr;
     private $cdivi;
 

Spacing +119 added lines, -119 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare(strict_types=1);
+declare(strict_types = 1);
 /**
  *
  *	Class to obtain eigenvalues and eigenvectors of a real matrix.
@@ -88,10 +88,10 @@ 
         //  Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
         //  Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         //  Fortran subroutine in EISPACK.
-        $this->d = $this->V[$this->n-1];
+        $this->d = $this->V[$this->n - 1];
         // Householder reduction to tridiagonal form.
-        for ($i = $this->n-1; $i > 0; --$i) {
-            $i_ = $i -1;
+        for ($i = $this->n - 1; $i > 0; --$i) {
+            $i_ = $i - 1;
             // Scale to avoid under/overflow.
             $h = $scale = 0.0;
             $scale += array_sum(array_map('abs', $this->d));
@@ -123,7 +123,7 @@ 
                     $f = $this->d[$j];
                     $this->V[$j][$i] = $f;
                     $g = $this->e[$j] + $this->V[$j][$j] * $f;
-                    for ($k = $j+1; $k <= $i_; ++$k) {
+                    for ($k = $j + 1; $k <= $i_; ++$k) {
                         $g += $this->V[$k][$j] * $this->d[$k];
                         $this->e[$k] += $this->V[$k][$j] * $f;
                     }
@@ -138,7 +138,7 @@ 
                     $f += $this->e[$j] * $this->d[$j];
                 }
                 $hh = $f / (2 * $h);
-                for ($j=0; $j < $i; ++$j) {
+                for ($j = 0; $j < $i; ++$j) {
                     $this->e[$j] -= $hh * $this->d[$j];
                 }
                 for ($j = 0; $j < $i; ++$j) {
@@ -147,7 +147,7 @@ 
                     for ($k = $j; $k <= $i_; ++$k) {
                         $this->V[$k][$j] -= ($f * $this->e[$k] + $g * $this->d[$k]);
                     }
-                    $this->d[$j] = $this->V[$i-1][$j];
+                    $this->d[$j] = $this->V[$i - 1][$j];
                     $this->V[$i][$j] = 0.0;
                 }
             }
@@ -155,18 +155,18 @@ 
         }
 
         // Accumulate transformations.
-        for ($i = 0; $i < $this->n-1; ++$i) {
-            $this->V[$this->n-1][$i] = $this->V[$i][$i];
+        for ($i = 0; $i < $this->n - 1; ++$i) {
+            $this->V[$this->n - 1][$i] = $this->V[$i][$i];
             $this->V[$i][$i] = 1.0;
-            $h = $this->d[$i+1];
+            $h = $this->d[$i + 1];
             if ($h != 0.0) {
                 for ($k = 0; $k <= $i; ++$k) {
-                    $this->d[$k] = $this->V[$k][$i+1] / $h;
+                    $this->d[$k] = $this->V[$k][$i + 1] / $h;
                 }
                 for ($j = 0; $j <= $i; ++$j) {
                     $g = 0.0;
                     for ($k = 0; $k <= $i; ++$k) {
-                        $g += $this->V[$k][$i+1] * $this->V[$k][$j];
+                        $g += $this->V[$k][$i + 1] * $this->V[$k][$j];
                     }
                     for ($k = 0; $k <= $i; ++$k) {
                         $this->V[$k][$j] -= $g * $this->d[$k];
@@ -174,13 +174,13 @@ 
                 }
             }
             for ($k = 0; $k <= $i; ++$k) {
-                $this->V[$k][$i+1] = 0.0;
+                $this->V[$k][$i + 1] = 0.0;
             }
         }
 
-        $this->d = $this->V[$this->n-1];
-        $this->V[$this->n-1] = array_fill(0, $j, 0.0);
-        $this->V[$this->n-1][$this->n-1] = 1.0;
+        $this->d = $this->V[$this->n - 1];
+        $this->V[$this->n - 1] = array_fill(0, $j, 0.0);
+        $this->V[$this->n - 1][$this->n - 1] = 1.0;
         $this->e[0] = 0.0;
     }
 
@@ -196,9 +196,9 @@ 
     private function tql2()
     {
         for ($i = 1; $i < $this->n; ++$i) {
-            $this->e[$i-1] = $this->e[$i];
+            $this->e[$i - 1] = $this->e[$i];
         }
-        $this->e[$this->n-1] = 0.0;
+        $this->e[$this->n - 1] = 0.0;
         $f = 0.0;
         $tst1 = 0.0;
         $eps  = pow(2.0, -52.0);
@@ -222,14 +222,14 @@ 
                     $iter += 1;
                     // Compute implicit shift
                     $g = $this->d[$l];
-                    $p = ($this->d[$l+1] - $g) / (2.0 * $this->e[$l]);
+                    $p = ($this->d[$l + 1] - $g) / (2.0 * $this->e[$l]);
                     $r = hypot($p, 1.0);
                     if ($p < 0) {
                         $r *= -1;
                     }
                     $this->d[$l] = $this->e[$l] / ($p + $r);
-                    $this->d[$l+1] = $this->e[$l] * ($p + $r);
-                    $dl1 = $this->d[$l+1];
+                    $this->d[$l + 1] = $this->e[$l] * ($p + $r);
+                    $dl1 = $this->d[$l + 1];
                     $h = $g - $this->d[$l];
                     for ($i = $l + 2; $i < $this->n; ++$i) {
                         $this->d[$i] -= $h;
@@ -241,22 +241,22 @@ 
                     $c2 = $c3 = $c;
                     $el1 = $this->e[$l + 1];
                     $s = $s2 = 0.0;
-                    for ($i = $m-1; $i >= $l; --$i) {
+                    for ($i = $m - 1; $i >= $l; --$i) {
                         $c3 = $c2;
                         $c2 = $c;
                         $s2 = $s;
                         $g  = $c * $this->e[$i];
                         $h  = $c * $p;
                         $r  = hypot($p, $this->e[$i]);
-                        $this->e[$i+1] = $s * $r;
+                        $this->e[$i + 1] = $s * $r;
                         $s = $this->e[$i] / $r;
                         $c = $p / $r;
                         $p = $c * $this->d[$i] - $s * $g;
-                        $this->d[$i+1] = $h + $s * ($c * $g + $s * $this->d[$i]);
+                        $this->d[$i + 1] = $h + $s * ($c * $g + $s * $this->d[$i]);
                         // Accumulate transformation.
                         for ($k = 0; $k < $this->n; ++$k) {
-                            $h = $this->V[$k][$i+1];
-                            $this->V[$k][$i+1] = $s * $this->V[$k][$i] + $c * $h;
+                            $h = $this->V[$k][$i + 1];
+                            $this->V[$k][$i + 1] = $s * $this->V[$k][$i] + $c * $h;
                             $this->V[$k][$i] = $c * $this->V[$k][$i] - $s * $h;
                         }
                     }
@@ -274,7 +274,7 @@ 
         for ($i = 0; $i < $this->n - 1; ++$i) {
             $k = $i;
             $p = $this->d[$i];
-            for ($j = $i+1; $j < $this->n; ++$j) {
+            for ($j = $i + 1; $j < $this->n; ++$j) {
                 if ($this->d[$j] < $p) {
                     $k = $j;
                     $p = $this->d[$j];
@@ -304,19 +304,19 @@ 
     private function orthes()
     {
         $low  = 0;
-        $high = $this->n-1;
+        $high = $this->n - 1;
 
-        for ($m = $low+1; $m <= $high-1; ++$m) {
+        for ($m = $low + 1; $m <= $high - 1; ++$m) {
             // Scale column.
             $scale = 0.0;
             for ($i = $m; $i <= $high; ++$i) {
-                $scale = $scale + abs($this->H[$i][$m-1]);
+                $scale = $scale + abs($this->H[$i][$m - 1]);
             }
             if ($scale != 0.0) {
                 // Compute Householder transformation.
                 $h = 0.0;
                 for ($i = $high; $i >= $m; --$i) {
-                    $this->ort[$i] = $this->H[$i][$m-1] / $scale;
+                    $this->ort[$i] = $this->H[$i][$m - 1] / $scale;
                     $h += $this->ort[$i] * $this->ort[$i];
                 }
                 $g = sqrt($h);
@@ -348,7 +348,7 @@ 
                     }
                 }
                 $this->ort[$m] = $scale * $this->ort[$m];
-                $this->H[$m][$m-1] = $scale * $g;
+                $this->H[$m][$m - 1] = $scale * $g;
             }
         }
 
@@ -358,10 +358,10 @@ 
                 $this->V[$i][$j] = ($i == $j ? 1.0 : 0.0);
             }
         }
-        for ($m = $high-1; $m >= $low+1; --$m) {
-            if ($this->H[$m][$m-1] != 0.0) {
-                for ($i = $m+1; $i <= $high; ++$i) {
-                    $this->ort[$i] = $this->H[$i][$m-1];
+        for ($m = $high - 1; $m >= $low + 1; --$m) {
+            if ($this->H[$m][$m - 1] != 0.0) {
+                for ($i = $m + 1; $i <= $high; ++$i) {
+                    $this->ort[$i] = $this->H[$i][$m - 1];
                 }
                 for ($j = $m; $j <= $high; ++$j) {
                     $g = 0.0;
@@ -369,7 +369,7 @@ 
                         $g += $this->ort[$i] * $this->V[$i][$j];
                     }
                     // Double division avoids possible underflow
-                    $g = ($g / $this->ort[$m]) / $this->H[$m][$m-1];
+                    $g = ($g / $this->ort[$m]) / $this->H[$m][$m - 1];
                     for ($i = $m; $i <= $high; ++$i) {
                         $this->V[$i][$j] += $g * $this->ort[$i];
                     }
@@ -424,7 +424,7 @@ 
                 $this->d[$i] = $this->H[$i][$i];
                 $this->e[$i] = 0.0;
             }
-            for ($j = max($i-1, 0); $j < $nn; ++$j) {
+            for ($j = max($i - 1, 0); $j < $nn; ++$j) {
                 $norm = $norm + abs($this->H[$i][$j]);
             }
         }
@@ -435,11 +435,11 @@ 
             // Look for single small sub-diagonal element
             $l = $n;
             while ($l > $low) {
-                $s = abs($this->H[$l-1][$l-1]) + abs($this->H[$l][$l]);
+                $s = abs($this->H[$l - 1][$l - 1]) + abs($this->H[$l][$l]);
                 if ($s == 0.0) {
                     $s = $norm;
                 }
-                if (abs($this->H[$l][$l-1]) < $eps * $s) {
+                if (abs($this->H[$l][$l - 1]) < $eps * $s) {
                     break;
                 }
                 --$l;
@@ -453,13 +453,13 @@ 
                 --$n;
                 $iter = 0;
             // Two roots found
-            } elseif ($l == $n-1) {
-                $w = $this->H[$n][$n-1] * $this->H[$n-1][$n];
-                $p = ($this->H[$n-1][$n-1] - $this->H[$n][$n]) / 2.0;
+            } elseif ($l == $n - 1) {
+                $w = $this->H[$n][$n - 1] * $this->H[$n - 1][$n];
+                $p = ($this->H[$n - 1][$n - 1] - $this->H[$n][$n]) / 2.0;
                 $q = $p * $p + $w;
                 $z = sqrt(abs($q));
                 $this->H[$n][$n] = $this->H[$n][$n] + $exshift;
-                $this->H[$n-1][$n-1] = $this->H[$n-1][$n-1] + $exshift;
+                $this->H[$n - 1][$n - 1] = $this->H[$n - 1][$n - 1] + $exshift;
                 $x = $this->H[$n][$n];
                 // Real pair
                 if ($q >= 0) {
@@ -468,14 +468,14 @@ 
                     } else {
                         $z = $p - $z;
                     }
-                    $this->d[$n-1] = $x + $z;
-                    $this->d[$n] = $this->d[$n-1];
+                    $this->d[$n - 1] = $x + $z;
+                    $this->d[$n] = $this->d[$n - 1];
                     if ($z != 0.0) {
                         $this->d[$n] = $x - $w / $z;
                     }
-                    $this->e[$n-1] = 0.0;
+                    $this->e[$n - 1] = 0.0;
                     $this->e[$n] = 0.0;
-                    $x = $this->H[$n][$n-1];
+                    $x = $this->H[$n][$n - 1];
                     $s = abs($x) + abs($z);
                     $p = $x / $s;
                     $q = $z / $s;
@@ -483,28 +483,28 @@ 
                     $p = $p / $r;
                     $q = $q / $r;
                     // Row modification
-                    for ($j = $n-1; $j < $nn; ++$j) {
-                        $z = $this->H[$n-1][$j];
-                        $this->H[$n-1][$j] = $q * $z + $p * $this->H[$n][$j];
+                    for ($j = $n - 1; $j < $nn; ++$j) {
+                        $z = $this->H[$n - 1][$j];
+                        $this->H[$n - 1][$j] = $q * $z + $p * $this->H[$n][$j];
                         $this->H[$n][$j] = $q * $this->H[$n][$j] - $p * $z;
                     }
                     // Column modification
                     for ($i = 0; $i <= $n; ++$i) {
-                        $z = $this->H[$i][$n-1];
-                        $this->H[$i][$n-1] = $q * $z + $p * $this->H[$i][$n];
+                        $z = $this->H[$i][$n - 1];
+                        $this->H[$i][$n - 1] = $q * $z + $p * $this->H[$i][$n];
                         $this->H[$i][$n] = $q * $this->H[$i][$n] - $p * $z;
                     }
                     // Accumulate transformations
                     for ($i = $low; $i <= $high; ++$i) {
-                        $z = $this->V[$i][$n-1];
-                        $this->V[$i][$n-1] = $q * $z + $p * $this->V[$i][$n];
+                        $z = $this->V[$i][$n - 1];
+                        $this->V[$i][$n - 1] = $q * $z + $p * $this->V[$i][$n];
                         $this->V[$i][$n] = $q * $this->V[$i][$n] - $p * $z;
                     }
                 // Complex pair
                 } else {
-                    $this->d[$n-1] = $x + $p;
+                    $this->d[$n - 1] = $x + $p;
                     $this->d[$n] = $x + $p;
-                    $this->e[$n-1] = $z;
+                    $this->e[$n - 1] = $z;
                     $this->e[$n] = -$z;
                 }
                 $n = $n - 2;
@@ -516,8 +516,8 @@ 
                 $y = 0.0;
                 $w = 0.0;
                 if ($l < $n) {
-                    $y = $this->H[$n-1][$n-1];
-                    $w = $this->H[$n][$n-1] * $this->H[$n-1][$n];
+                    $y = $this->H[$n - 1][$n - 1];
+                    $w = $this->H[$n][$n - 1] * $this->H[$n - 1][$n];
                 }
                 // Wilkinson's original ad hoc shift
                 if ($iter == 10) {
@@ -525,7 +525,7 @@ 
                     for ($i = $low; $i <= $n; ++$i) {
                         $this->H[$i][$i] -= $x;
                     }
-                    $s = abs($this->H[$n][$n-1]) + abs($this->H[$n-1][$n-2]);
+                    $s = abs($this->H[$n][$n - 1]) + abs($this->H[$n - 1][$n - 2]);
                     $x = $y = 0.75 * $s;
                     $w = -0.4375 * $s * $s;
                 }
@@ -554,9 +554,9 @@ 
                     $z = $this->H[$m][$m];
                     $r = $x - $z;
                     $s = $y - $z;
-                    $p = ($r * $s - $w) / $this->H[$m+1][$m] + $this->H[$m][$m+1];
-                    $q = $this->H[$m+1][$m+1] - $z - $r - $s;
-                    $r = $this->H[$m+2][$m+1];
+                    $p = ($r * $s - $w) / $this->H[$m + 1][$m] + $this->H[$m][$m + 1];
+                    $q = $this->H[$m + 1][$m + 1] - $z - $r - $s;
+                    $r = $this->H[$m + 2][$m + 1];
                     $s = abs($p) + abs($q) + abs($r);
                     $p = $p / $s;
                     $q = $q / $s;
@@ -564,25 +564,25 @@ 
                     if ($m == $l) {
                         break;
                     }
-                    if (abs($this->H[$m][$m-1]) * (abs($q) + abs($r)) <
-                        $eps * (abs($p) * (abs($this->H[$m-1][$m-1]) + abs($z) + abs($this->H[$m+1][$m+1])))) {
+                    if (abs($this->H[$m][$m - 1]) * (abs($q) + abs($r)) <
+                        $eps * (abs($p) * (abs($this->H[$m - 1][$m - 1]) + abs($z) + abs($this->H[$m + 1][$m + 1])))) {
                         break;
                     }
                     --$m;
                 }
                 for ($i = $m + 2; $i <= $n; ++$i) {
-                    $this->H[$i][$i-2] = 0.0;
-                    if ($i > $m+2) {
-                        $this->H[$i][$i-3] = 0.0;
+                    $this->H[$i][$i - 2] = 0.0;
+                    if ($i > $m + 2) {
+                        $this->H[$i][$i - 3] = 0.0;
                     }
                 }
                 // Double QR step involving rows l:n and columns m:n
-                for ($k = $m; $k <= $n-1; ++$k) {
-                    $notlast = ($k != $n-1);
+                for ($k = $m; $k <= $n - 1; ++$k) {
+                    $notlast = ($k != $n - 1);
                     if ($k != $m) {
-                        $p = $this->H[$k][$k-1];
-                        $q = $this->H[$k+1][$k-1];
-                        $r = ($notlast ? $this->H[$k+2][$k-1] : 0.0);
+                        $p = $this->H[$k][$k - 1];
+                        $q = $this->H[$k + 1][$k - 1];
+                        $r = ($notlast ? $this->H[$k + 2][$k - 1] : 0.0);
                         $x = abs($p) + abs($q) + abs($r);
                         if ($x != 0.0) {
                             $p = $p / $x;
@@ -599,9 +599,9 @@ 
                     }
                     if ($s != 0) {
                         if ($k != $m) {
-                            $this->H[$k][$k-1] = -$s * $x;
+                            $this->H[$k][$k - 1] = -$s * $x;
                         } elseif ($l != $m) {
-                            $this->H[$k][$k-1] = -$this->H[$k][$k-1];
+                            $this->H[$k][$k - 1] = -$this->H[$k][$k - 1];
                         }
                         $p = $p + $s;
                         $x = $p / $s;
@@ -611,33 +611,33 @@ 
                         $r = $r / $p;
                         // Row modification
                         for ($j = $k; $j < $nn; ++$j) {
-                            $p = $this->H[$k][$j] + $q * $this->H[$k+1][$j];
+                            $p = $this->H[$k][$j] + $q * $this->H[$k + 1][$j];
                             if ($notlast) {
-                                $p = $p + $r * $this->H[$k+2][$j];
-                                $this->H[$k+2][$j] = $this->H[$k+2][$j] - $p * $z;
+                                $p = $p + $r * $this->H[$k + 2][$j];
+                                $this->H[$k + 2][$j] = $this->H[$k + 2][$j] - $p * $z;
                             }
                             $this->H[$k][$j] = $this->H[$k][$j] - $p * $x;
-                            $this->H[$k+1][$j] = $this->H[$k+1][$j] - $p * $y;
+                            $this->H[$k + 1][$j] = $this->H[$k + 1][$j] - $p * $y;
                         }
                         // Column modification
-                        for ($i = 0; $i <= min($n, $k+3); ++$i) {
-                            $p = $x * $this->H[$i][$k] + $y * $this->H[$i][$k+1];
+                        for ($i = 0; $i <= min($n, $k + 3); ++$i) {
+                            $p = $x * $this->H[$i][$k] + $y * $this->H[$i][$k + 1];
                             if ($notlast) {
-                                $p = $p + $z * $this->H[$i][$k+2];
-                                $this->H[$i][$k+2] = $this->H[$i][$k+2] - $p * $r;
+                                $p = $p + $z * $this->H[$i][$k + 2];
+                                $this->H[$i][$k + 2] = $this->H[$i][$k + 2] - $p * $r;
                             }
                             $this->H[$i][$k] = $this->H[$i][$k] - $p;
-                            $this->H[$i][$k+1] = $this->H[$i][$k+1] - $p * $q;
+                            $this->H[$i][$k + 1] = $this->H[$i][$k + 1] - $p * $q;
                         }
                         // Accumulate transformations
                         for ($i = $low; $i <= $high; ++$i) {
-                            $p = $x * $this->V[$i][$k] + $y * $this->V[$i][$k+1];
+                            $p = $x * $this->V[$i][$k] + $y * $this->V[$i][$k + 1];
                             if ($notlast) {
-                                $p = $p + $z * $this->V[$i][$k+2];
-                                $this->V[$i][$k+2] = $this->V[$i][$k+2] - $p * $r;
+                                $p = $p + $z * $this->V[$i][$k + 2];
+                                $this->V[$i][$k + 2] = $this->V[$i][$k + 2] - $p * $r;
                             }
                             $this->V[$i][$k] = $this->V[$i][$k] - $p;
-                            $this->V[$i][$k+1] = $this->V[$i][$k+1] - $p * $q;
+                            $this->V[$i][$k + 1] = $this->V[$i][$k + 1] - $p * $q;
                         }
                     }  // ($s != 0)
                 }  // k loop
@@ -649,14 +649,14 @@ 
             return;
         }
 
-        for ($n = $nn-1; $n >= 0; --$n) {
+        for ($n = $nn - 1; $n >= 0; --$n) {
             $p = $this->d[$n];
             $q = $this->e[$n];
             // Real vector
             if ($q == 0) {
                 $l = $n;
                 $this->H[$n][$n] = 1.0;
-                for ($i = $n-1; $i >= 0; --$i) {
+                for ($i = $n - 1; $i >= 0; --$i) {
                     $w = $this->H[$i][$i] - $p;
                     $r = 0.0;
                     for ($j = $l; $j <= $n; ++$j) {
@@ -675,15 +675,15 @@ 
                             }
                         // Solve real equations
                         } else {
-                            $x = $this->H[$i][$i+1];
-                            $y = $this->H[$i+1][$i];
+                            $x = $this->H[$i][$i + 1];
+                            $y = $this->H[$i + 1][$i];
                             $q = ($this->d[$i] - $p) * ($this->d[$i] - $p) + $this->e[$i] * $this->e[$i];
                             $t = ($x * $s - $z * $r) / $q;
                             $this->H[$i][$n] = $t;
                             if (abs($x) > abs($z)) {
-                                $this->H[$i+1][$n] = (-$r - $w * $t) / $x;
+                                $this->H[$i + 1][$n] = (-$r - $w * $t) / $x;
                             } else {
-                                $this->H[$i+1][$n] = (-$s - $y * $t) / $z;
+                                $this->H[$i + 1][$n] = (-$s - $y * $t) / $z;
                             }
                         }
                         // Overflow control
@@ -697,24 +697,24 @@ 
                 }
             // Complex vector
             } elseif ($q < 0) {
-                $l = $n-1;
+                $l = $n - 1;
                 // Last vector component imaginary so matrix is triangular
-                if (abs($this->H[$n][$n-1]) > abs($this->H[$n-1][$n])) {
-                    $this->H[$n-1][$n-1] = $q / $this->H[$n][$n-1];
-                    $this->H[$n-1][$n] = -($this->H[$n][$n] - $p) / $this->H[$n][$n-1];
+                if (abs($this->H[$n][$n - 1]) > abs($this->H[$n - 1][$n])) {
+                    $this->H[$n - 1][$n - 1] = $q / $this->H[$n][$n - 1];
+                    $this->H[$n - 1][$n] = -($this->H[$n][$n] - $p) / $this->H[$n][$n - 1];
                 } else {
-                    $this->cdiv(0.0, -$this->H[$n-1][$n], $this->H[$n-1][$n-1] - $p, $q);
-                    $this->H[$n-1][$n-1] = $this->cdivr;
-                    $this->H[$n-1][$n]   = $this->cdivi;
+                    $this->cdiv(0.0, -$this->H[$n - 1][$n], $this->H[$n - 1][$n - 1] - $p, $q);
+                    $this->H[$n - 1][$n - 1] = $this->cdivr;
+                    $this->H[$n - 1][$n]   = $this->cdivi;
                 }
-                $this->H[$n][$n-1] = 0.0;
+                $this->H[$n][$n - 1] = 0.0;
                 $this->H[$n][$n] = 1.0;
-                for ($i = $n-2; $i >= 0; --$i) {
+                for ($i = $n - 2; $i >= 0; --$i) {
                     // double ra,sa,vr,vi;
                     $ra = 0.0;
                     $sa = 0.0;
                     for ($j = $l; $j <= $n; ++$j) {
-                        $ra = $ra + $this->H[$i][$j] * $this->H[$j][$n-1];
+                        $ra = $ra + $this->H[$i][$j] * $this->H[$j][$n - 1];
                         $sa = $sa + $this->H[$i][$j] * $this->H[$j][$n];
                     }
                     $w = $this->H[$i][$i] - $p;
@@ -726,34 +726,34 @@ 
                         $l = $i;
                         if ($this->e[$i] == 0) {
                             $this->cdiv(-$ra, -$sa, $w, $q);
-                            $this->H[$i][$n-1] = $this->cdivr;
+                            $this->H[$i][$n - 1] = $this->cdivr;
                             $this->H[$i][$n]   = $this->cdivi;
                         } else {
                             // Solve complex equations
-                            $x = $this->H[$i][$i+1];
-                            $y = $this->H[$i+1][$i];
+                            $x = $this->H[$i][$i + 1];
+                            $y = $this->H[$i + 1][$i];
                             $vr = ($this->d[$i] - $p) * ($this->d[$i] - $p) + $this->e[$i] * $this->e[$i] - $q * $q;
                             $vi = ($this->d[$i] - $p) * 2.0 * $q;
                             if ($vr == 0.0 & $vi == 0.0) {
                                 $vr = $eps * $norm * (abs($w) + abs($q) + abs($x) + abs($y) + abs($z));
                             }
                             $this->cdiv($x * $r - $z * $ra + $q * $sa, $x * $s - $z * $sa - $q * $ra, $vr, $vi);
-                            $this->H[$i][$n-1] = $this->cdivr;
+                            $this->H[$i][$n - 1] = $this->cdivr;
                             $this->H[$i][$n]   = $this->cdivi;
                             if (abs($x) > (abs($z) + abs($q))) {
-                                $this->H[$i+1][$n-1] = (-$ra - $w * $this->H[$i][$n-1] + $q * $this->H[$i][$n]) / $x;
-                                $this->H[$i+1][$n] = (-$sa - $w * $this->H[$i][$n] - $q * $this->H[$i][$n-1]) / $x;
+                                $this->H[$i + 1][$n - 1] = (-$ra - $w * $this->H[$i][$n - 1] + $q * $this->H[$i][$n]) / $x;
+                                $this->H[$i + 1][$n] = (-$sa - $w * $this->H[$i][$n] - $q * $this->H[$i][$n - 1]) / $x;
                             } else {
-                                $this->cdiv(-$r - $y * $this->H[$i][$n-1], -$s - $y * $this->H[$i][$n], $z, $q);
-                                $this->H[$i+1][$n-1] = $this->cdivr;
-                                $this->H[$i+1][$n]   = $this->cdivi;
+                                $this->cdiv(-$r - $y * $this->H[$i][$n - 1], -$s - $y * $this->H[$i][$n], $z, $q);
+                                $this->H[$i + 1][$n - 1] = $this->cdivr;
+                                $this->H[$i + 1][$n]   = $this->cdivi;
                             }
                         }
                         // Overflow control
-                        $t = max(abs($this->H[$i][$n-1]), abs($this->H[$i][$n]));
+                        $t = max(abs($this->H[$i][$n - 1]), abs($this->H[$i][$n]));
                         if (($eps * $t) * $t > 1) {
                             for ($j = $i; $j <= $n; ++$j) {
-                                $this->H[$j][$n-1] = $this->H[$j][$n-1] / $t;
+                                $this->H[$j][$n - 1] = $this->H[$j][$n - 1] / $t;
                                 $this->H[$j][$n]   = $this->H[$j][$n] / $t;
                             }
                         }
@@ -772,7 +772,7 @@ 
         }
 
         // Back transformation to get eigenvectors of original matrix
-        for ($j = $nn-1; $j >= $low; --$j) {
+        for ($j = $nn - 1; $j >= $low; --$j) {
             for ($i = $low; $i <= $high; ++$i) {
                 $z = 0.0;
                 for ($k = $low; $k <= min($j, $high); ++$k) {
@@ -829,13 +829,13 @@ 
 
         // Always return the eigenvectors of length 1.0
         $vectors = new Matrix($vectors);
-        $vectors = array_map(function ($vect) {
+        $vectors = array_map(function($vect) {
             $sum = 0;
-            for ($i=0; $i<count($vect); $i++) {
+            for ($i = 0; $i < count($vect); $i++) {
                 $sum += $vect[$i] ** 2;
             }
             $sum = sqrt($sum);
-            for ($i=0; $i<count($vect); $i++) {
+            for ($i = 0; $i < count($vect); $i++) {
                 $vect[$i] /= $sum;
             }
             return $vect;