JAMA

# Source for file EigenvalueDecomposition.php Documentation is available at EigenvalueDecomposition.php <?php /** * @package JAMA * * Class to obtain eigenvalues and eigenvectors of a real matrix. * * If A is symmetric, then A = V*D*V' where the eigenvalue matrix D * is diagonal and the eigenvector matrix V is orthogonal (i.e. * A = V.times(D.times(V.transpose())) and V.times(V.transpose()) * equals the identity matrix). * * If A is not symmetric, then the eigenvalue matrix D is block diagonal * with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, * lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda]. The * columns of V represent the eigenvectors in the sense that A*V = V*D, * i.e. A.times(V) equals V.times(D). The matrix V may be badly * conditioned, or even singular, so the validity of the equation * A = V*D*inverse(V) depends upon V.cond(). * * @author Paul Meagher * @license PHP v3.0 * @version 1.1 */ class EigenvalueDecomposition { /** * Row and column dimension (square matrix). * @var int */ private $n; /** * Internal symmetry flag. * @var int */ private $issymmetric; /** * Arrays for internal storage of eigenvalues. * @var array */ private $d = array(); private $e = array(); /** * Array for internal storage of eigenvectors. * @var array */ private $V = array(); /** * Array for internal storage of nonsymmetric Hessenberg form. * @var array */ private $H = array(); /** * Working storage for nonsymmetric algorithm. * @var array */ private $ort; /** * Used for complex scalar division. * @var float */ private $cdivr; private $cdivi; /** * Symmetric Householder reduction to tridiagonal form. * * @access private */ private function tred2 () { // This is derived from the Algol procedures tred2 by // 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]; // Householder reduction to tridiagonal form. 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)); if ($scale == 0.0) { $this->e[$i] = $this->d[$i_]; $this->d = array_slice($this->V[$i_], 0, $i_); for ($j = 0; $j < $i; ++$j) { $this->V[$j][$i] = $this->V[$i][$j] = 0.0; } } else { // Generate Householder vector. for ($k = 0; $k < $i; ++$k) { $this->d[$k] /= $scale; $h += pow($this->d[$k], 2); } $f = $this->d[$i_]; $g = sqrt($h); if ($f > 0) { $g = -$g; } $this->e[$i] = $scale * $g; $h = $h - $f * $g; $this->d[$i_] = $f - $g; for ($j = 0; $j < $i; ++$j) { $this->e[$j] = 0.0; } // Apply similarity transformation to remaining columns. for ($j = 0; $j < $i; ++$j) { $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) { $g += $this->V[$k][$j] * $this->d[$k]; $this->e[$k] += $this->V[$k][$j] * $f; } $this->e[$j] = $g; } $f = 0.0; for ($j = 0; $j < $i; ++$j) { $this->e[$j] /= $h; $f += $this->e[$j] * $this->d[$j]; } $hh = $f / (2 * $h); for ($j=0; $j < $i; ++$j) { $this->e[$j] -= $hh * $this->d[$j]; } for ($j = 0; $j < $i; ++$j) { $f = $this->d[$j]; $g = $this->e[$j]; 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->V[$i][$j] = 0.0; } } $this->d[$i] = $h; } // Accumulate transformations. 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]; if ($h != 0.0) { for ($k = 0; $k <= $i; ++$k) { $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]; } for ($k = 0; $k <= $i; ++$k) { $this->V[$k][$j] -= $g * $this->d[$k]; } } } for ($k = 0; $k <= $i; ++$k) { $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->e[0] = 0.0; } /** * Symmetric tridiagonal QL algorithm. * * This is derived from the Algol procedures tql2, by * Bowdler, Martin, Reinsch, and Wilkinson, Handbook for * Auto. Comp., Vol.ii-Linear Algebra, and the corresponding * Fortran subroutine in EISPACK. * * @access private */ private function tql2() { for ($i = 1; $i < $this->n; ++$i) { $this->e[$i-1] = $this->e[$i]; } $this->e[$this->n-1] = 0.0; $f = 0.0; $tst1 = 0.0; $eps = pow(2.0,-52.0); for ($l = 0; $l < $this->n; ++$l) { // Find small subdiagonal element $tst1 = max($tst1, abs($this->d[$l]) + abs($this->e[$l])); $m = $l; while ($m < $this->n) { if (abs($this->e[$m]) <= $eps * $tst1) break; ++$m; } // If m == l, $this->d[l] is an eigenvalue, // otherwise, iterate. if ($m > $l) { $iter = 0; do { // Could check iteration count here. $iter += 1; // Compute implicit shift $g = $this->d[$l]; $p = ($this->d[$l+1] - $g) / (2.0 * $this->e[$l]); $r = hypo($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]; $h = $g - $this->d[$l]; for ($i = $l + 2; $i < $this->n; ++$i) $this->d[$i] -= $h; $f += $h; // Implicit QL transformation. $p = $this->d[$m]; $c = 1.0; $c2 = $c3 = $c; $el1 = $this->e[$l + 1]; $s = $s2 = 0.0; for ($i = $m-1; $i >= $l; --$i) { $c3 = $c2; $c2 = $c; $s2 = $s; $g = $c * $this->e[$i]; $h = $c * $p; $r = hypo($p, $this->e[$i]); $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]); // 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; $this->V[$k][$i] = $c * $this->V[$k][$i] - $s * $h; } } $p = -$s * $s2 * $c3 * $el1 * $this->e[$l] / $dl1; $this->e[$l] = $s * $p; $this->d[$l] = $c * $p; // Check for convergence. } while (abs($this->e[$l]) > $eps * $tst1); } $this->d[$l] = $this->d[$l] + $f; $this->e[$l] = 0.0; } // Sort eigenvalues and corresponding vectors. for ($i = 0; $i < $this->n - 1; ++$i) { $k = $i; $p = $this->d[$i]; for ($j = $i+1; $j < $this->n; ++$j) { if ($this->d[$j] < $p) { $k = $j; $p = $this->d[$j]; } } if ($k != $i) { $this->d[$k] = $this->d[$i]; $this->d[$i] = $p; for ($j = 0; $j < $this->n; ++$j) { $p = $this->V[$j][$i]; $this->V[$j][$i] = $this->V[$j][$k]; $this->V[$j][$k] = $p; } } } } /** * Nonsymmetric reduction to Hessenberg form. * * This is derived from the Algol procedures orthes and ortran, * by Martin and Wilkinson, Handbook for Auto. Comp., * Vol.ii-Linear Algebra, and the corresponding * Fortran subroutines in EISPACK. * * @access private */ private function orthes () { $low = 0; $high = $this->n-1; 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]); } 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; $h += $this->ort[$i] * $this->ort[$i]; } $g = sqrt($h); if ($this->ort[$m] > 0) { $g *= -1; } $h -= $this->ort[$m] * $g; $this->ort[$m] -= $g; // Apply Householder similarity transformation // H = (I -u * u' / h) * H * (I -u * u') / h) for ($j = $m; $j < $this->n; ++$j) { $f = 0.0; for ($i = $high; $i >= $m; --$i) { $f += $this->ort[$i] * $this->H[$i][$j]; } $f /= $h; for ($i = $m; $i <= $high; ++$i) { $this->H[$i][$j] -= $f * $this->ort[$i]; } } for ($i = 0; $i <= $high; ++$i) { $f = 0.0; for ($j = $high; $j >= $m; --$j) { $f += $this->ort[$j] * $this->H[$i][$j]; } $f = $f / $h; for ($j = $m; $j <= $high; ++$j) { $this->H[$i][$j] -= $f * $this->ort[$j]; } } $this->ort[$m] = $scale * $this->ort[$m]; $this->H[$m][$m-1] = $scale * $g; } } // Accumulate transformations (Algol's ortran). for ($i = 0; $i < $this->n; ++$i) { for ($j = 0; $j < $this->n; ++$j) { $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 ($j = $m; $j <= $high; ++$j) { $g = 0.0; for ($i = $m; $i <= $high; ++$i) { $g += $this->ort[$i] * $this->V[$i][$j]; } // Double division avoids possible underflow $g = ($g / $this->ort[$m]) / $this->H[$m][$m-1]; for ($i = $m; $i <= $high; ++$i) { $this->V[$i][$j] += $g * $this->ort[$i]; } } } } } /** * Performs complex division. * * @access private */ private function cdiv($xr, $xi, $yr, $yi) { if (abs($yr) > abs($yi)) { $r = $yi / $yr; $d = $yr + $r * $yi; $this->cdivr = ($xr + $r * $xi) / $d; $this->cdivi = ($xi - $r * $xr) / $d; } else { $r = $yr / $yi; $d = $yi + $r * $yr; $this->cdivr = ($r * $xr + $xi) / $d; $this->cdivi = ($r * $xi - $xr) / $d; } } /** * Nonsymmetric reduction from Hessenberg to real Schur form. * * Code is derived from the Algol procedure hqr2, * by Martin and Wilkinson, Handbook for Auto. Comp., * Vol.ii-Linear Algebra, and the corresponding * Fortran subroutine in EISPACK. * * @access private */ private function hqr2 () { // Initialize $nn = $this->n; $n = $nn - 1; $low = 0; $high = $nn - 1; $eps = pow(2.0, -52.0); $exshift = 0.0; $p = $q = $r = $s = $z = 0; // Store roots isolated by balanc and compute matrix norm $norm = 0.0; for ($i = 0; $i < $nn; ++$i) { if (($i < $low) OR ($i > $high)) { $this->d[$i] = $this->H[$i][$i]; $this->e[$i] = 0.0; } for ($j = max($i-1, 0); $j < $nn; ++$j) { $norm = $norm + abs($this->H[$i][$j]); } } // Outer loop over eigenvalue index $iter = 0; while ($n >= $low) { // 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]); if ($s == 0.0) { $s = $norm; } if (abs($this->H[$l][$l-1]) < $eps * $s) { break; } --$l; } // Check for convergence // One root found if ($l == $n) { $this->H[$n][$n] = $this->H[$n][$n] + $exshift; $this->d[$n] = $this->H[$n][$n]; $this->e[$n] = 0.0; --$n; $iter = 0; // Two roots found } else if ($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; $x = $this->H[$n][$n]; // Real pair if ($q >= 0) { if ($p >= 0) { $z = $p + $z; } else { $z = $p - $z; } $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] = 0.0; $x = $this->H[$n][$n-1]; $s = abs($x) + abs($z); $p = $x / $s; $q = $z / $s; $r = sqrt($p * $p + $q * $q); $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]; $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]; $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]; $this->V[$i][$n] = $q * $this->V[$i][$n] - $p * $z; } // Complex pair } else { $this->d[$n-1] = $x + $p; $this->d[$n] = $x + $p; $this->e[$n-1] = $z; $this->e[$n] = -$z; } $n = $n - 2; $iter = 0; // No convergence yet } else { // Form shift $x = $this->H[$n][$n]; $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]; } // Wilkinson's original ad hoc shift if ($iter == 10) { $exshift += $x; 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]); $x = $y = 0.75 * $s; $w = -0.4375 * $s * $s; } // MATLAB's new ad hoc shift if ($iter == 30) { $s = ($y - $x) / 2.0; $s = $s * $s + $w; if ($s > 0) { $s = sqrt($s); if ($y < $x) { $s = -$s; } $s = $x - $w / (($y - $x) / 2.0 + $s); for ($i = $low; $i <= $n; ++$i) { $this->H[$i][$i] -= $s; } $exshift += $s; $x = $y = $w = 0.964; } } // Could check iteration count here. $iter = $iter + 1; // Look for two consecutive small sub-diagonal elements $m = $n - 2; while ($m >= $l) { $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]; $s = abs($p) + abs($q) + abs($r); $p = $p / $s; $q = $q / $s; $r = $r / $s; 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])))) { 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; } } // Double QR step involving rows l:n and columns m:n 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); $x = abs($p) + abs($q) + abs($r); if ($x != 0.0) { $p = $p / $x; $q = $q / $x; $r = $r / $x; } } if ($x == 0.0) { break; } $s = sqrt($p * $p + $q * $q + $r * $r); if ($p < 0) { $s = -$s; } if ($s != 0) { if ($k != $m) { $this->H[$k][$k-1] = -$s * $x; } elseif ($l != $m) { $this->H[$k][$k-1] = -$this->H[$k][$k-1]; } $p = $p + $s; $x = $p / $s; $y = $q / $s; $z = $r / $s; $q = $q / $p; $r = $r / $p; // Row modification for ($j = $k; $j < $nn; ++$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; } $this->H[$k][$j] = $this->H[$k][$j] - $p * $x; $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]; if ($notlast) { $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; } // Accumulate transformations for ($i = $low; $i <= $high; ++$i) { $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; } $this->V[$i][$k] = $this->V[$i][$k] - $p; $this->V[$i][$k+1] = $this->V[$i][$k+1] - $p * $q; } } // ($s != 0) } // k loop } // check convergence } // while ($n >= $low) // Backsubstitute to find vectors of upper triangular form if ($norm == 0.0) { return; } 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) { $w = $this->H[$i][$i] - $p; $r = 0.0; for ($j = $l; $j <= $n; ++$j) { $r = $r + $this->H[$i][$j] * $this->H[$j][$n]; } if ($this->e[$i] < 0.0) { $z = $w; $s = $r; } else { $l = $i; if ($this->e[$i] == 0.0) { if ($w != 0.0) { $this->H[$i][$n] = -$r / $w; } else { $this->H[$i][$n] = -$r / ($eps * $norm); } // Solve real equations } else { $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; } else { $this->H[$i+1][$n] = (-$s - $y * $t) / $z; } } // Overflow control $t = abs($this->H[$i][$n]); if (($eps * $t) * $t > 1) { for ($j = $i; $j <= $n; ++$j) { $this->H[$j][$n] = $this->H[$j][$n] / $t; } } } } // Complex vector } else if ($q < 0) { $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]; } 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->H[$n][$n-1] = 0.0; $this->H[$n][$n] = 1.0; 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]; $sa = $sa + $this->H[$i][$j] * $this->H[$j][$n]; } $w = $this->H[$i][$i] - $p; if ($this->e[$i] < 0.0) { $z = $w; $r = $ra; $s = $sa; } else { $l = $i; if ($this->e[$i] == 0) { $this->cdiv(-$ra, -$sa, $w, $q); $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]; $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] = $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; } 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; } } // Overflow control $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] = $this->H[$j][$n] / $t; } } } // end else } // end for } // end else for complex case } // end for // Vectors of isolated roots for ($i = 0; $i < $nn; ++$i) { if ($i < $low | $i > $high) { for ($j = $i; $j < $nn; ++$j) { $this->V[$i][$j] = $this->H[$i][$j]; } } } // Back transformation to get eigenvectors of original matrix for ($j = $nn-1; $j >= $low; --$j) { for ($i = $low; $i <= $high; ++$i) { $z = 0.0; for ($k = $low; $k <= min($j,$high); ++$k) { $z = $z + $this->V[$i][$k] * $this->H[$k][$j]; } $this->V[$i][$j] = $z; } } } // end hqr2 /** * Constructor: Check for symmetry, then construct the eigenvalue decomposition * * @access public * @param A Square matrix * @return Structure to access D and V. */ public function __construct($Arg) { $this->A = $Arg->getArray(); $this->n = $Arg->getColumnDimension(); $issymmetric = true; for ($j = 0; ($j < $this->n) & $issymmetric; ++$j) { for ($i = 0; ($i < $this->n) & $issymmetric; ++$i) { $issymmetric = ($this->A[$i][$j] == $this->A[$j][$i]); } } if ($issymmetric) { $this->V = $this->A; // Tridiagonalize. $this->tred2(); // Diagonalize. $this->tql2(); } else { $this->H = $this->A; $this->ort = array(); // Reduce to Hessenberg form. $this->orthes(); // Reduce Hessenberg to real Schur form. $this->hqr2(); } } /** * Return the eigenvector matrix * * @access public * @return V */ public function getV() { return new Matrix($this->V, $this->n, $this->n); } /** * Return the real parts of the eigenvalues * * @access public * @return real(diag(D)) */ public function getRealEigenvalues() { return $this->d; } /** * Return the imaginary parts of the eigenvalues * * @access public * @return imag(diag(D)) */ public function getImagEigenvalues() { return $this->e; } /** * Return the block diagonal eigenvalue matrix * * @access public * @return D */ public function getD() { for ($i = 0; $i < $this->n; ++$i) { $D[$i] = array_fill(0, $this->n, 0.0); $D[$i][$i] = $this->d[$i]; if ($this->e[$i] == 0) { continue; } $o = ($this->e[$i] > 0) ? $i + 1 : $i - 1; $D[$i][$o] = $this->e[$i]; } return new Matrix($D); } } // class EigenvalueDecomposition Documentation generated on Fri, 12 Oct 2012 00:16:09 +0200 by phpDocumentor 1.4.4