Subversion Repositories eFlore/Applications.cel

<?php

/**

 *	@package JAMA

 *

 *	For an m-by-n matrix A with m >= n, the singular value decomposition is

 *	an m-by-n orthogonal matrix U, an n-by-n diagonal matrix S, and

 *	an n-by-n orthogonal matrix V so that A = U*S*V'.

 *

 *	The singular values, sigma[$k] = S[$k][$k], are ordered so that

 *	sigma[0] >= sigma[1] >= ... >= sigma[n-1].

 *

 *	The singular value decompostion always exists, so the constructor will

 *	never fail.  The matrix condition number and the effective numerical

 *	rank can be computed from this decomposition.

 *

 *	@author  Paul Meagher

 *	@license PHP v3.0

 *	@version 1.1

 */

class SingularValueDecomposition  {

	/**

	 *	Internal storage of U.

	 *	@var array

	 */

	private $U = array();

	/**

	 *	Internal storage of V.

	 *	@var array

	 */

	private $V = array();

	/**

	 *	Internal storage of singular values.

	 *	@var array

	 */

	private $s = array();

	/**

	 *	Row dimension.

	 *	@var int

	 */

	private $m;

	/**

	 *	Column dimension.

	 *	@var int

	 */

	private $n;

	/**

	 *	Construct the singular value decomposition

	 *

	 *	Derived from LINPACK code.

	 *

	 *	@param $A Rectangular matrix

	 *	@return Structure to access U, S and V.

	 */

	public function __construct($Arg) {

		// Initialize.

		$A = $Arg->getArrayCopy();

		$this->m = $Arg->getRowDimension();

		$this->n = $Arg->getColumnDimension();

		$nu      = min($this->m, $this->n);

		$e       = array();

		$work    = array();

		$wantu   = true;

		$wantv   = true;

		$nct = min($this->m - 1, $this->n);

		$nrt = max(0, min($this->n - 2, $this->m));

		// Reduce A to bidiagonal form, storing the diagonal elements

		// in s and the super-diagonal elements in e.

		for ($k = 0; $k < max($nct,$nrt); ++$k) {

			if ($k < $nct) {

				// Compute the transformation for the k-th column and

				// place the k-th diagonal in s[$k].

				// Compute 2-norm of k-th column without under/overflow.

				$this->s[$k] = 0;

				for ($i = $k; $i < $this->m; ++$i) {

					$this->s[$k] = hypo($this->s[$k], $A[$i][$k]);

				}

				if ($this->s[$k] != 0.0) {

					if ($A[$k][$k] < 0.0) {

						$this->s[$k] = -$this->s[$k];

					}

					for ($i = $k; $i < $this->m; ++$i) {

						$A[$i][$k] /= $this->s[$k];

					}

					$A[$k][$k] += 1.0;

				}

				$this->s[$k] = -$this->s[$k];

			}

			for ($j = $k + 1; $j < $this->n; ++$j) {

				if (($k < $nct) & ($this->s[$k] != 0.0)) {

					// Apply the transformation.

					$t = 0;

					for ($i = $k; $i < $this->m; ++$i) {

						$t += $A[$i][$k] * $A[$i][$j];

					}

					$t = -$t / $A[$k][$k];

					for ($i = $k; $i < $this->m; ++$i) {

						$A[$i][$j] += $t * $A[$i][$k];

					}

					// Place the k-th row of A into e for the

					// subsequent calculation of the row transformation.

					$e[$j] = $A[$k][$j];

				}

			}

			if ($wantu AND ($k < $nct)) {

				// Place the transformation in U for subsequent back

				// multiplication.

				for ($i = $k; $i < $this->m; ++$i) {

					$this->U[$i][$k] = $A[$i][$k];

				}

			}

			if ($k < $nrt) {

				// Compute the k-th row transformation and place the

				// k-th super-diagonal in e[$k].

				// Compute 2-norm without under/overflow.

				$e[$k] = 0;

				for ($i = $k + 1; $i < $this->n; ++$i) {

					$e[$k] = hypo($e[$k], $e[$i]);

				}

				if ($e[$k] != 0.0) {

					if ($e[$k+1] < 0.0) {

						$e[$k] = -$e[$k];

					}

					for ($i = $k + 1; $i < $this->n; ++$i) {

						$e[$i] /= $e[$k];

					}

					$e[$k+1] += 1.0;

				}

				$e[$k] = -$e[$k];

				if (($k+1 < $this->m) AND ($e[$k] != 0.0)) {

					// Apply the transformation.

					for ($i = $k+1; $i < $this->m; ++$i) {

						$work[$i] = 0.0;

					}

					for ($j = $k+1; $j < $this->n; ++$j) {

						for ($i = $k+1; $i < $this->m; ++$i) {

							$work[$i] += $e[$j] * $A[$i][$j];

						}

					}

					for ($j = $k + 1; $j < $this->n; ++$j) {

						$t = -$e[$j] / $e[$k+1];

						for ($i = $k + 1; $i < $this->m; ++$i) {

							$A[$i][$j] += $t * $work[$i];

						}

					}

				}

				if ($wantv) {

					// Place the transformation in V for subsequent

					// back multiplication.

					for ($i = $k + 1; $i < $this->n; ++$i) {

						$this->V[$i][$k] = $e[$i];

					}

				}

			}

		}

		// Set up the final bidiagonal matrix or order p.

		$p = min($this->n, $this->m + 1);

		if ($nct < $this->n) {

			$this->s[$nct] = $A[$nct][$nct];

		}

		if ($this->m < $p) {

			$this->s[$p-1] = 0.0;

		}

		if ($nrt + 1 < $p) {

			$e[$nrt] = $A[$nrt][$p-1];

		}

		$e[$p-1] = 0.0;

		// If required, generate U.

		if ($wantu) {

			for ($j = $nct; $j < $nu; ++$j) {

				for ($i = 0; $i < $this->m; ++$i) {

					$this->U[$i][$j] = 0.0;

				}

				$this->U[$j][$j] = 1.0;

			}

			for ($k = $nct - 1; $k >= 0; --$k) {

				if ($this->s[$k] != 0.0) {

					for ($j = $k + 1; $j < $nu; ++$j) {

						$t = 0;

						for ($i = $k; $i < $this->m; ++$i) {

							$t += $this->U[$i][$k] * $this->U[$i][$j];

						}

						$t = -$t / $this->U[$k][$k];

						for ($i = $k; $i < $this->m; ++$i) {

							$this->U[$i][$j] += $t * $this->U[$i][$k];

						}

					}

					for ($i = $k; $i < $this->m; ++$i ) {

						$this->U[$i][$k] = -$this->U[$i][$k];

					}

					$this->U[$k][$k] = 1.0 + $this->U[$k][$k];

					for ($i = 0; $i < $k - 1; ++$i) {

						$this->U[$i][$k] = 0.0;

					}

				} else {

					for ($i = 0; $i < $this->m; ++$i) {

						$this->U[$i][$k] = 0.0;

					}

					$this->U[$k][$k] = 1.0;

				}

			}

		}

		// If required, generate V.

		if ($wantv) {

			for ($k = $this->n - 1; $k >= 0; --$k) {

				if (($k < $nrt) AND ($e[$k] != 0.0)) {

					for ($j = $k + 1; $j < $nu; ++$j) {

						$t = 0;

						for ($i = $k + 1; $i < $this->n; ++$i) {

							$t += $this->V[$i][$k]* $this->V[$i][$j];

						}

						$t = -$t / $this->V[$k+1][$k];

						for ($i = $k + 1; $i < $this->n; ++$i) {

							$this->V[$i][$j] += $t * $this->V[$i][$k];

						}

					}

				}

				for ($i = 0; $i < $this->n; ++$i) {

					$this->V[$i][$k] = 0.0;

				}

				$this->V[$k][$k] = 1.0;

			}

		}

		// Main iteration loop for the singular values.

		$pp   = $p - 1;

		$iter = 0;

		$eps  = pow(2.0, -52.0);

		while ($p > 0) {

			// Here is where a test for too many iterations would go.

			// This section of the program inspects for negligible

			// elements in the s and e arrays.  On completion the

			// variables kase and k are set as follows:

			// kase = 1  if s(p) and e[k-1] are negligible and k<p

			// kase = 2  if s(k) is negligible and k<p

			// kase = 3  if e[k-1] is negligible, k<p, and

			//           s(k), ..., s(p) are not negligible (qr step).

			// kase = 4  if e(p-1) is negligible (convergence).

			for ($k = $p - 2; $k >= -1; --$k) {

				if ($k == -1) {

					break;

				}

				if (abs($e[$k]) <= $eps * (abs($this->s[$k]) + abs($this->s[$k+1]))) {

					$e[$k] = 0.0;

					break;

				}

			}

			if ($k == $p - 2) {

				$kase = 4;

			} else {

				for ($ks = $p - 1; $ks >= $k; --$ks) {

					if ($ks == $k) {

						break;

					}

					$t = ($ks != $p ? abs($e[$ks]) : 0.) + ($ks != $k + 1 ? abs($e[$ks-1]) : 0.);

					if (abs($this->s[$ks]) <= $eps * $t)  {

						$this->s[$ks] = 0.0;

						break;

					}

				}

				if ($ks == $k) {

					$kase = 3;

				} else if ($ks == $p-1) {

					$kase = 1;

				} else {

					$kase = 2;

					$k = $ks;

				}

			}

			++$k;

			// Perform the task indicated by kase.

			switch ($kase) {

				// Deflate negligible s(p).

				case 1:

						$f = $e[$p-2];

						$e[$p-2] = 0.0;

						for ($j = $p - 2; $j >= $k; --$j) {

							$t  = hypo($this->s[$j],$f);

							$cs = $this->s[$j] / $t;

							$sn = $f / $t;

							$this->s[$j] = $t;

							if ($j != $k) {

								$f = -$sn * $e[$j-1];

								$e[$j-1] = $cs * $e[$j-1];

							}

							if ($wantv) {

								for ($i = 0; $i < $this->n; ++$i) {

									$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$p-1];

									$this->V[$i][$p-1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$p-1];

									$this->V[$i][$j] = $t;

								}

							}

						}

						break;

				// Split at negligible s(k).

				case 2:

						$f = $e[$k-1];

						$e[$k-1] = 0.0;

						for ($j = $k; $j < $p; ++$j) {

							$t = hypo($this->s[$j], $f);

							$cs = $this->s[$j] / $t;

							$sn = $f / $t;

							$this->s[$j] = $t;

							$f = -$sn * $e[$j];

							$e[$j] = $cs * $e[$j];

							if ($wantu) {

								for ($i = 0; $i < $this->m; ++$i) {

									$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$k-1];

									$this->U[$i][$k-1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$k-1];

									$this->U[$i][$j] = $t;

								}

							}

						}

						break;

				// Perform one qr step.

				case 3:

						// Calculate the shift.

						$scale = max(max(max(max(

									abs($this->s[$p-1]),abs($this->s[$p-2])),abs($e[$p-2])),

									abs($this->s[$k])), abs($e[$k]));

						$sp   = $this->s[$p-1] / $scale;

						$spm1 = $this->s[$p-2] / $scale;

						$epm1 = $e[$p-2] / $scale;

						$sk   = $this->s[$k] / $scale;

						$ek   = $e[$k] / $scale;

						$b    = (($spm1 + $sp) * ($spm1 - $sp) + $epm1 * $epm1) / 2.0;

						$c    = ($sp * $epm1) * ($sp * $epm1);

						$shift = 0.0;

						if (($b != 0.0) || ($c != 0.0)) {

							$shift = sqrt($b * $b + $c);

							if ($b < 0.0) {

								$shift = -$shift;

							}

							$shift = $c / ($b + $shift);

						}

						$f = ($sk + $sp) * ($sk - $sp) + $shift;

						$g = $sk * $ek;

						// Chase zeros.

						for ($j = $k; $j < $p-1; ++$j) {

							$t  = hypo($f,$g);

							$cs = $f/$t;

							$sn = $g/$t;

							if ($j != $k) {

								$e[$j-1] = $t;

							}

							$f = $cs * $this->s[$j] + $sn * $e[$j];

							$e[$j] = $cs * $e[$j] - $sn * $this->s[$j];

							$g = $sn * $this->s[$j+1];

							$this->s[$j+1] = $cs * $this->s[$j+1];

							if ($wantv) {

								for ($i = 0; $i < $this->n; ++$i) {

									$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$j+1];

									$this->V[$i][$j+1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$j+1];

									$this->V[$i][$j] = $t;

								}

							}

							$t = hypo($f,$g);

							$cs = $f/$t;

							$sn = $g/$t;

							$this->s[$j] = $t;

							$f = $cs * $e[$j] + $sn * $this->s[$j+1];

							$this->s[$j+1] = -$sn * $e[$j] + $cs * $this->s[$j+1];

							$g = $sn * $e[$j+1];

							$e[$j+1] = $cs * $e[$j+1];

							if ($wantu && ($j < $this->m - 1)) {

								for ($i = 0; $i < $this->m; ++$i) {

									$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$j+1];

									$this->U[$i][$j+1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$j+1];

									$this->U[$i][$j] = $t;

								}

							}

						}

						$e[$p-2] = $f;

						$iter = $iter + 1;

						break;

				// Convergence.

				case 4:

						// Make the singular values positive.

						if ($this->s[$k] <= 0.0) {

							$this->s[$k] = ($this->s[$k] < 0.0 ? -$this->s[$k] : 0.0);

							if ($wantv) {

								for ($i = 0; $i <= $pp; ++$i) {

									$this->V[$i][$k] = -$this->V[$i][$k];

								}

							}

						}

						// Order the singular values.

						while ($k < $pp) {

							if ($this->s[$k] >= $this->s[$k+1]) {

								break;

							}

							$t = $this->s[$k];

							$this->s[$k] = $this->s[$k+1];

							$this->s[$k+1] = $t;

							if ($wantv AND ($k < $this->n - 1)) {

								for ($i = 0; $i < $this->n; ++$i) {

									$t = $this->V[$i][$k+1];

									$this->V[$i][$k+1] = $this->V[$i][$k];

									$this->V[$i][$k] = $t;

								}

							}

							if ($wantu AND ($k < $this->m-1)) {

								for ($i = 0; $i < $this->m; ++$i) {

									$t = $this->U[$i][$k+1];

									$this->U[$i][$k+1] = $this->U[$i][$k];

									$this->U[$i][$k] = $t;

								}

							}

							++$k;

						}

						$iter = 0;

						--$p;

						break;

			} // end switch

		} // end while

	} // end constructor

	/**

	 *	Return the left singular vectors

	 *

	 *	@access public

	 *	@return U

	 */

	public function getU() {

		return new Matrix($this->U, $this->m, min($this->m + 1, $this->n));

	}

	/**

	 *	Return the right singular vectors

	 *

	 *	@access public

	 *	@return V

	 */

	public function getV() {

		return new Matrix($this->V);

	}

	/**

	 *	Return the one-dimensional array of singular values

	 *

	 *	@access public

	 *	@return diagonal of S.

	 */

	public function getSingularValues() {

		return $this->s;

	}

	/**

	 *	Return the diagonal matrix of singular values

	 *

	 *	@access public

	 *	@return S

	 */

	public function getS() {

		for ($i = 0; $i < $this->n; ++$i) {

			for ($j = 0; $j < $this->n; ++$j) {

				$S[$i][$j] = 0.0;

			}

			$S[$i][$i] = $this->s[$i];

		}

		return new Matrix($S);

	}

	/**

	 *	Two norm

	 *

	 *	@access public

	 *	@return max(S)

	 */

	public function norm2() {

		return $this->s[0];

	}

	/**

	 *	Two norm condition number

	 *

	 *	@access public

	 *	@return max(S)/min(S)

	 */

	public function cond() {

		return $this->s[0] / $this->s[min($this->m, $this->n) - 1];

	}

	/**

	 *	Effective numerical matrix rank

	 *

	 *	@access public

	 *	@return Number of nonnegligible singular values.

	 */

	public function rank() {

		$eps = pow(2.0, -52.0);

		$tol = max($this->m, $this->n) * $this->s[0] * $eps;

		$r = 0;

		for ($i = 0; $i < count($this->s); ++$i) {

			if ($this->s[$i] > $tol) {

				++$r;

			}

		}

		return $r;

	}

}	//	class SingularValueDecomposition