<?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

