MINI

C:/siak73/app/Siak73/application/third_party/PHPExcel/Shared/JAMA/
files >> C:/siak73/app/Siak73/application/third_party/PHPExcel/Shared/JAMA/SingularValueDecomposition.php
 <?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