Subversion Repositories eFlore/Applications.cel

Rev

Rev 2388 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2388 jpm 1
<?php
2
/**
3
 *	@package JAMA
4
 *
5
 *	Class to obtain eigenvalues and eigenvectors of a real matrix.
6
 *
7
 *	If A is symmetric, then A = V*D*V' where the eigenvalue matrix D
8
 *	is diagonal and the eigenvector matrix V is orthogonal (i.e.
9
 *	A = V.times(D.times(V.transpose())) and V.times(V.transpose())
10
 *	equals the identity matrix).
11
 *
12
 *	If A is not symmetric, then the eigenvalue matrix D is block diagonal
13
 *	with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
14
 *	lambda + i*mu, in 2-by-2 blocks, [lambda, mu; -mu, lambda].  The
15
 *	columns of V represent the eigenvectors in the sense that A*V = V*D,
16
 *	i.e. A.times(V) equals V.times(D).  The matrix V may be badly
17
 *	conditioned, or even singular, so the validity of the equation
18
 *	A = V*D*inverse(V) depends upon V.cond().
19
 *
20
 *	@author  Paul Meagher
21
 *	@license PHP v3.0
22
 *	@version 1.1
23
 */
24
class EigenvalueDecomposition {
25
 
26
	/**
27
	 *	Row and column dimension (square matrix).
28
	 *	@var int
29
	 */
30
	private $n;
31
 
32
	/**
33
	 *	Internal symmetry flag.
34
	 *	@var int
35
	 */
36
	private $issymmetric;
37
 
38
	/**
39
	 *	Arrays for internal storage of eigenvalues.
40
	 *	@var array
41
	 */
42
	private $d = array();
43
	private $e = array();
44
 
45
	/**
46
	 *	Array for internal storage of eigenvectors.
47
	 *	@var array
48
	 */
49
	private $V = array();
50
 
51
	/**
52
	*	Array for internal storage of nonsymmetric Hessenberg form.
53
	*	@var array
54
	*/
55
	private $H = array();
56
 
57
	/**
58
	*	Working storage for nonsymmetric algorithm.
59
	*	@var array
60
	*/
61
	private $ort;
62
 
63
	/**
64
	*	Used for complex scalar division.
65
	*	@var float
66
	*/
67
	private $cdivr;
68
	private $cdivi;
69
 
70
 
71
	/**
72
	 *	Symmetric Householder reduction to tridiagonal form.
73
	 *
74
	 *	@access private
75
	 */
76
	private function tred2 () {
77
		//  This is derived from the Algol procedures tred2 by
78
		//  Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
79
		//  Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
80
		//  Fortran subroutine in EISPACK.
81
		$this->d = $this->V[$this->n-1];
82
		// Householder reduction to tridiagonal form.
83
		for ($i = $this->n-1; $i > 0; --$i) {
84
			$i_ = $i -1;
85
			// Scale to avoid under/overflow.
86
			$h = $scale = 0.0;
87
			$scale += array_sum(array_map(abs, $this->d));
88
			if ($scale == 0.0) {
89
				$this->e[$i] = $this->d[$i_];
90
				$this->d = array_slice($this->V[$i_], 0, $i_);
91
				for ($j = 0; $j < $i; ++$j) {
92
					$this->V[$j][$i] = $this->V[$i][$j] = 0.0;
93
				}
94
			} else {
95
				// Generate Householder vector.
96
				for ($k = 0; $k < $i; ++$k) {
97
					$this->d[$k] /= $scale;
98
					$h += pow($this->d[$k], 2);
99
				}
100
				$f = $this->d[$i_];
101
				$g = sqrt($h);
102
				if ($f > 0) {
103
					$g = -$g;
104
				}
105
				$this->e[$i] = $scale * $g;
106
				$h = $h - $f * $g;
107
				$this->d[$i_] = $f - $g;
108
				for ($j = 0; $j < $i; ++$j) {
109
					$this->e[$j] = 0.0;
110
				}
111
				// Apply similarity transformation to remaining columns.
112
				for ($j = 0; $j < $i; ++$j) {
113
					$f = $this->d[$j];
114
					$this->V[$j][$i] = $f;
115
					$g = $this->e[$j] + $this->V[$j][$j] * $f;
116
					for ($k = $j+1; $k <= $i_; ++$k) {
117
						$g += $this->V[$k][$j] * $this->d[$k];
118
						$this->e[$k] += $this->V[$k][$j] * $f;
119
					}
120
					$this->e[$j] = $g;
121
				}
122
				$f = 0.0;
123
				for ($j = 0; $j < $i; ++$j) {
124
					$this->e[$j] /= $h;
125
					$f += $this->e[$j] * $this->d[$j];
126
				}
127
				$hh = $f / (2 * $h);
128
				for ($j=0; $j < $i; ++$j) {
129
					$this->e[$j] -= $hh * $this->d[$j];
130
				}
131
				for ($j = 0; $j < $i; ++$j) {
132
					$f = $this->d[$j];
133
					$g = $this->e[$j];
134
					for ($k = $j; $k <= $i_; ++$k) {
135
						$this->V[$k][$j] -= ($f * $this->e[$k] + $g * $this->d[$k]);
136
					}
137
					$this->d[$j] = $this->V[$i-1][$j];
138
					$this->V[$i][$j] = 0.0;
139
				}
140
			}
141
			$this->d[$i] = $h;
142
		}
143
 
144
		// Accumulate transformations.
145
		for ($i = 0; $i < $this->n-1; ++$i) {
146
			$this->V[$this->n-1][$i] = $this->V[$i][$i];
147
			$this->V[$i][$i] = 1.0;
148
			$h = $this->d[$i+1];
149
			if ($h != 0.0) {
150
				for ($k = 0; $k <= $i; ++$k) {
151
					$this->d[$k] = $this->V[$k][$i+1] / $h;
152
				}
153
				for ($j = 0; $j <= $i; ++$j) {
154
					$g = 0.0;
155
					for ($k = 0; $k <= $i; ++$k) {
156
						$g += $this->V[$k][$i+1] * $this->V[$k][$j];
157
					}
158
					for ($k = 0; $k <= $i; ++$k) {
159
						$this->V[$k][$j] -= $g * $this->d[$k];
160
					}
161
				}
162
			}
163
			for ($k = 0; $k <= $i; ++$k) {
164
				$this->V[$k][$i+1] = 0.0;
165
			}
166
		}
167
 
168
		$this->d = $this->V[$this->n-1];
169
		$this->V[$this->n-1] = array_fill(0, $j, 0.0);
170
		$this->V[$this->n-1][$this->n-1] = 1.0;
171
		$this->e[0] = 0.0;
172
	}
173
 
174
 
175
	/**
176
	 *	Symmetric tridiagonal QL algorithm.
177
	 *
178
	 *	This is derived from the Algol procedures tql2, by
179
	 *	Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
180
	 *	Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
181
	 *	Fortran subroutine in EISPACK.
182
	 *
183
	 *	@access private
184
	 */
185
	private function tql2() {
186
		for ($i = 1; $i < $this->n; ++$i) {
187
			$this->e[$i-1] = $this->e[$i];
188
		}
189
		$this->e[$this->n-1] = 0.0;
190
		$f = 0.0;
191
		$tst1 = 0.0;
192
		$eps  = pow(2.0,-52.0);
193
 
194
		for ($l = 0; $l < $this->n; ++$l) {
195
			// Find small subdiagonal element
196
			$tst1 = max($tst1, abs($this->d[$l]) + abs($this->e[$l]));
197
			$m = $l;
198
			while ($m < $this->n) {
199
				if (abs($this->e[$m]) <= $eps * $tst1)
200
					break;
201
				++$m;
202
			}
203
			// If m == l, $this->d[l] is an eigenvalue,
204
			// otherwise, iterate.
205
			if ($m > $l) {
206
				$iter = 0;
207
				do {
208
					// Could check iteration count here.
209
					$iter += 1;
210
					// Compute implicit shift
211
					$g = $this->d[$l];
212
					$p = ($this->d[$l+1] - $g) / (2.0 * $this->e[$l]);
213
					$r = hypo($p, 1.0);
214
					if ($p < 0)
215
						$r *= -1;
216
					$this->d[$l] = $this->e[$l] / ($p + $r);
217
					$this->d[$l+1] = $this->e[$l] * ($p + $r);
218
					$dl1 = $this->d[$l+1];
219
					$h = $g - $this->d[$l];
220
					for ($i = $l + 2; $i < $this->n; ++$i)
221
						$this->d[$i] -= $h;
222
					$f += $h;
223
					// Implicit QL transformation.
224
					$p = $this->d[$m];
225
					$c = 1.0;
226
					$c2 = $c3 = $c;
227
					$el1 = $this->e[$l + 1];
228
					$s = $s2 = 0.0;
229
					for ($i = $m-1; $i >= $l; --$i) {
230
						$c3 = $c2;
231
						$c2 = $c;
232
						$s2 = $s;
233
						$g  = $c * $this->e[$i];
234
						$h  = $c * $p;
235
						$r  = hypo($p, $this->e[$i]);
236
						$this->e[$i+1] = $s * $r;
237
						$s = $this->e[$i] / $r;
238
						$c = $p / $r;
239
						$p = $c * $this->d[$i] - $s * $g;
240
						$this->d[$i+1] = $h + $s * ($c * $g + $s * $this->d[$i]);
241
						// Accumulate transformation.
242
						for ($k = 0; $k < $this->n; ++$k) {
243
							$h = $this->V[$k][$i+1];
244
							$this->V[$k][$i+1] = $s * $this->V[$k][$i] + $c * $h;
245
							$this->V[$k][$i] = $c * $this->V[$k][$i] - $s * $h;
246
						}
247
					}
248
					$p = -$s * $s2 * $c3 * $el1 * $this->e[$l] / $dl1;
249
					$this->e[$l] = $s * $p;
250
					$this->d[$l] = $c * $p;
251
				// Check for convergence.
252
				} while (abs($this->e[$l]) > $eps * $tst1);
253
			}
254
			$this->d[$l] = $this->d[$l] + $f;
255
			$this->e[$l] = 0.0;
256
		}
257
 
258
		// Sort eigenvalues and corresponding vectors.
259
		for ($i = 0; $i < $this->n - 1; ++$i) {
260
			$k = $i;
261
			$p = $this->d[$i];
262
			for ($j = $i+1; $j < $this->n; ++$j) {
263
				if ($this->d[$j] < $p) {
264
					$k = $j;
265
					$p = $this->d[$j];
266
				}
267
			}
268
			if ($k != $i) {
269
				$this->d[$k] = $this->d[$i];
270
				$this->d[$i] = $p;
271
				for ($j = 0; $j < $this->n; ++$j) {
272
					$p = $this->V[$j][$i];
273
					$this->V[$j][$i] = $this->V[$j][$k];
274
					$this->V[$j][$k] = $p;
275
				}
276
			}
277
		}
278
	}
279
 
280
 
281
	/**
282
	 *	Nonsymmetric reduction to Hessenberg form.
283
	 *
284
	 *	This is derived from the Algol procedures orthes and ortran,
285
	 *	by Martin and Wilkinson, Handbook for Auto. Comp.,
286
	 *	Vol.ii-Linear Algebra, and the corresponding
287
	 *	Fortran subroutines in EISPACK.
288
	 *
289
	 *	@access private
290
	 */
291
	private function orthes () {
292
		$low  = 0;
293
		$high = $this->n-1;
294
 
295
		for ($m = $low+1; $m <= $high-1; ++$m) {
296
			// Scale column.
297
			$scale = 0.0;
298
			for ($i = $m; $i <= $high; ++$i) {
299
				$scale = $scale + abs($this->H[$i][$m-1]);
300
			}
301
			if ($scale != 0.0) {
302
				// Compute Householder transformation.
303
				$h = 0.0;
304
				for ($i = $high; $i >= $m; --$i) {
305
					$this->ort[$i] = $this->H[$i][$m-1] / $scale;
306
					$h += $this->ort[$i] * $this->ort[$i];
307
				}
308
				$g = sqrt($h);
309
				if ($this->ort[$m] > 0) {
310
					$g *= -1;
311
				}
312
				$h -= $this->ort[$m] * $g;
313
				$this->ort[$m] -= $g;
314
				// Apply Householder similarity transformation
315
				// H = (I -u * u' / h) * H * (I -u * u') / h)
316
				for ($j = $m; $j < $this->n; ++$j) {
317
					$f = 0.0;
318
					for ($i = $high; $i >= $m; --$i) {
319
						$f += $this->ort[$i] * $this->H[$i][$j];
320
					}
321
					$f /= $h;
322
					for ($i = $m; $i <= $high; ++$i) {
323
						$this->H[$i][$j] -= $f * $this->ort[$i];
324
					}
325
				}
326
				for ($i = 0; $i <= $high; ++$i) {
327
					$f = 0.0;
328
					for ($j = $high; $j >= $m; --$j) {
329
						$f += $this->ort[$j] * $this->H[$i][$j];
330
					}
331
					$f = $f / $h;
332
					for ($j = $m; $j <= $high; ++$j) {
333
						$this->H[$i][$j] -= $f * $this->ort[$j];
334
					}
335
				}
336
				$this->ort[$m] = $scale * $this->ort[$m];
337
				$this->H[$m][$m-1] = $scale * $g;
338
			}
339
		}
340
 
341
		// Accumulate transformations (Algol's ortran).
342
		for ($i = 0; $i < $this->n; ++$i) {
343
			for ($j = 0; $j < $this->n; ++$j) {
344
				$this->V[$i][$j] = ($i == $j ? 1.0 : 0.0);
345
			}
346
		}
347
		for ($m = $high-1; $m >= $low+1; --$m) {
348
			if ($this->H[$m][$m-1] != 0.0) {
349
				for ($i = $m+1; $i <= $high; ++$i) {
350
					$this->ort[$i] = $this->H[$i][$m-1];
351
				}
352
				for ($j = $m; $j <= $high; ++$j) {
353
					$g = 0.0;
354
					for ($i = $m; $i <= $high; ++$i) {
355
						$g += $this->ort[$i] * $this->V[$i][$j];
356
					}
357
					// Double division avoids possible underflow
358
					$g = ($g / $this->ort[$m]) / $this->H[$m][$m-1];
359
					for ($i = $m; $i <= $high; ++$i) {
360
						$this->V[$i][$j] += $g * $this->ort[$i];
361
					}
362
				}
363
			}
364
		}
365
	}
366
 
367
 
368
	/**
369
	 *	Performs complex division.
370
	 *
371
	 *	@access private
372
	 */
373
	private function cdiv($xr, $xi, $yr, $yi) {
374
		if (abs($yr) > abs($yi)) {
375
			$r = $yi / $yr;
376
			$d = $yr + $r * $yi;
377
			$this->cdivr = ($xr + $r * $xi) / $d;
378
			$this->cdivi = ($xi - $r * $xr) / $d;
379
		} else {
380
			$r = $yr / $yi;
381
			$d = $yi + $r * $yr;
382
			$this->cdivr = ($r * $xr + $xi) / $d;
383
			$this->cdivi = ($r * $xi - $xr) / $d;
384
		}
385
	}
386
 
387
 
388
	/**
389
	 *	Nonsymmetric reduction from Hessenberg to real Schur form.
390
	 *
391
	 *	Code is derived from the Algol procedure hqr2,
392
	 *	by Martin and Wilkinson, Handbook for Auto. Comp.,
393
	 *	Vol.ii-Linear Algebra, and the corresponding
394
	 *	Fortran subroutine in EISPACK.
395
	 *
396
	 *	@access private
397
	 */
398
	private function hqr2 () {
399
		//  Initialize
400
		$nn = $this->n;
401
		$n  = $nn - 1;
402
		$low = 0;
403
		$high = $nn - 1;
404
		$eps = pow(2.0, -52.0);
405
		$exshift = 0.0;
406
		$p = $q = $r = $s = $z = 0;
407
		// Store roots isolated by balanc and compute matrix norm
408
		$norm = 0.0;
409
 
410
		for ($i = 0; $i < $nn; ++$i) {
411
			if (($i < $low) OR ($i > $high)) {
412
				$this->d[$i] = $this->H[$i][$i];
413
				$this->e[$i] = 0.0;
414
			}
415
			for ($j = max($i-1, 0); $j < $nn; ++$j) {
416
				$norm = $norm + abs($this->H[$i][$j]);
417
			}
418
		}
419
 
420
		// Outer loop over eigenvalue index
421
		$iter = 0;
422
		while ($n >= $low) {
423
			// Look for single small sub-diagonal element
424
			$l = $n;
425
			while ($l > $low) {
426
				$s = abs($this->H[$l-1][$l-1]) + abs($this->H[$l][$l]);
427
				if ($s == 0.0) {
428
					$s = $norm;
429
				}
430
				if (abs($this->H[$l][$l-1]) < $eps * $s) {
431
					break;
432
				}
433
				--$l;
434
			}
435
			// Check for convergence
436
			// One root found
437
			if ($l == $n) {
438
				$this->H[$n][$n] = $this->H[$n][$n] + $exshift;
439
				$this->d[$n] = $this->H[$n][$n];
440
				$this->e[$n] = 0.0;
441
				--$n;
442
				$iter = 0;
443
			// Two roots found
444
			} else if ($l == $n-1) {
445
				$w = $this->H[$n][$n-1] * $this->H[$n-1][$n];
446
				$p = ($this->H[$n-1][$n-1] - $this->H[$n][$n]) / 2.0;
447
				$q = $p * $p + $w;
448
				$z = sqrt(abs($q));
449
				$this->H[$n][$n] = $this->H[$n][$n] + $exshift;
450
				$this->H[$n-1][$n-1] = $this->H[$n-1][$n-1] + $exshift;
451
				$x = $this->H[$n][$n];
452
				// Real pair
453
				if ($q >= 0) {
454
					if ($p >= 0) {
455
						$z = $p + $z;
456
					} else {
457
						$z = $p - $z;
458
					}
459
					$this->d[$n-1] = $x + $z;
460
					$this->d[$n] = $this->d[$n-1];
461
					if ($z != 0.0) {
462
						$this->d[$n] = $x - $w / $z;
463
					}
464
					$this->e[$n-1] = 0.0;
465
					$this->e[$n] = 0.0;
466
					$x = $this->H[$n][$n-1];
467
					$s = abs($x) + abs($z);
468
					$p = $x / $s;
469
					$q = $z / $s;
470
					$r = sqrt($p * $p + $q * $q);
471
					$p = $p / $r;
472
					$q = $q / $r;
473
					// Row modification
474
					for ($j = $n-1; $j < $nn; ++$j) {
475
						$z = $this->H[$n-1][$j];
476
						$this->H[$n-1][$j] = $q * $z + $p * $this->H[$n][$j];
477
						$this->H[$n][$j] = $q * $this->H[$n][$j] - $p * $z;
478
					}
479
					// Column modification
480
					for ($i = 0; $i <= n; ++$i) {
481
						$z = $this->H[$i][$n-1];
482
						$this->H[$i][$n-1] = $q * $z + $p * $this->H[$i][$n];
483
						$this->H[$i][$n] = $q * $this->H[$i][$n] - $p * $z;
484
					}
485
					// Accumulate transformations
486
					for ($i = $low; $i <= $high; ++$i) {
487
						$z = $this->V[$i][$n-1];
488
						$this->V[$i][$n-1] = $q * $z + $p * $this->V[$i][$n];
489
						$this->V[$i][$n] = $q * $this->V[$i][$n] - $p * $z;
490
					}
491
				// Complex pair
492
				} else {
493
					$this->d[$n-1] = $x + $p;
494
					$this->d[$n] = $x + $p;
495
					$this->e[$n-1] = $z;
496
					$this->e[$n] = -$z;
497
				}
498
				$n = $n - 2;
499
				$iter = 0;
500
			// No convergence yet
501
			} else {
502
				// Form shift
503
				$x = $this->H[$n][$n];
504
				$y = 0.0;
505
				$w = 0.0;
506
				if ($l < $n) {
507
					$y = $this->H[$n-1][$n-1];
508
					$w = $this->H[$n][$n-1] * $this->H[$n-1][$n];
509
				}
510
				// Wilkinson's original ad hoc shift
511
				if ($iter == 10) {
512
					$exshift += $x;
513
					for ($i = $low; $i <= $n; ++$i) {
514
						$this->H[$i][$i] -= $x;
515
					}
516
					$s = abs($this->H[$n][$n-1]) + abs($this->H[$n-1][$n-2]);
517
					$x = $y = 0.75 * $s;
518
					$w = -0.4375 * $s * $s;
519
				}
520
				// MATLAB's new ad hoc shift
521
				if ($iter == 30) {
522
					$s = ($y - $x) / 2.0;
523
					$s = $s * $s + $w;
524
					if ($s > 0) {
525
						$s = sqrt($s);
526
						if ($y < $x) {
527
							$s = -$s;
528
						}
529
						$s = $x - $w / (($y - $x) / 2.0 + $s);
530
						for ($i = $low; $i <= $n; ++$i) {
531
							$this->H[$i][$i] -= $s;
532
						}
533
						$exshift += $s;
534
						$x = $y = $w = 0.964;
535
					}
536
				}
537
				// Could check iteration count here.
538
				$iter = $iter + 1;
539
				// Look for two consecutive small sub-diagonal elements
540
				$m = $n - 2;
541
				while ($m >= $l) {
542
					$z = $this->H[$m][$m];
543
					$r = $x - $z;
544
					$s = $y - $z;
545
					$p = ($r * $s - $w) / $this->H[$m+1][$m] + $this->H[$m][$m+1];
546
					$q = $this->H[$m+1][$m+1] - $z - $r - $s;
547
					$r = $this->H[$m+2][$m+1];
548
					$s = abs($p) + abs($q) + abs($r);
549
					$p = $p / $s;
550
					$q = $q / $s;
551
					$r = $r / $s;
552
					if ($m == $l) {
553
						break;
554
					}
555
					if (abs($this->H[$m][$m-1]) * (abs($q) + abs($r)) <
556
						$eps * (abs($p) * (abs($this->H[$m-1][$m-1]) + abs($z) + abs($this->H[$m+1][$m+1])))) {
557
						break;
558
					}
559
					--$m;
560
				}
561
				for ($i = $m + 2; $i <= $n; ++$i) {
562
					$this->H[$i][$i-2] = 0.0;
563
					if ($i > $m+2) {
564
						$this->H[$i][$i-3] = 0.0;
565
					}
566
				}
567
				// Double QR step involving rows l:n and columns m:n
568
				for ($k = $m; $k <= $n-1; ++$k) {
569
					$notlast = ($k != $n-1);
570
					if ($k != $m) {
571
						$p = $this->H[$k][$k-1];
572
						$q = $this->H[$k+1][$k-1];
573
						$r = ($notlast ? $this->H[$k+2][$k-1] : 0.0);
574
						$x = abs($p) + abs($q) + abs($r);
575
						if ($x != 0.0) {
576
							$p = $p / $x;
577
							$q = $q / $x;
578
							$r = $r / $x;
579
						}
580
					}
581
					if ($x == 0.0) {
582
						break;
583
					}
584
					$s = sqrt($p * $p + $q * $q + $r * $r);
585
					if ($p < 0) {
586
						$s = -$s;
587
					}
588
					if ($s != 0) {
589
						if ($k != $m) {
590
							$this->H[$k][$k-1] = -$s * $x;
591
						} elseif ($l != $m) {
592
							$this->H[$k][$k-1] = -$this->H[$k][$k-1];
593
						}
594
						$p = $p + $s;
595
						$x = $p / $s;
596
						$y = $q / $s;
597
						$z = $r / $s;
598
						$q = $q / $p;
599
						$r = $r / $p;
600
						// Row modification
601
						for ($j = $k; $j < $nn; ++$j) {
602
							$p = $this->H[$k][$j] + $q * $this->H[$k+1][$j];
603
							if ($notlast) {
604
								$p = $p + $r * $this->H[$k+2][$j];
605
								$this->H[$k+2][$j] = $this->H[$k+2][$j] - $p * $z;
606
							}
607
							$this->H[$k][$j] = $this->H[$k][$j] - $p * $x;
608
							$this->H[$k+1][$j] = $this->H[$k+1][$j] - $p * $y;
609
						}
610
						// Column modification
611
						for ($i = 0; $i <= min($n, $k+3); ++$i) {
612
							$p = $x * $this->H[$i][$k] + $y * $this->H[$i][$k+1];
613
							if ($notlast) {
614
								$p = $p + $z * $this->H[$i][$k+2];
615
								$this->H[$i][$k+2] = $this->H[$i][$k+2] - $p * $r;
616
							}
617
							$this->H[$i][$k] = $this->H[$i][$k] - $p;
618
							$this->H[$i][$k+1] = $this->H[$i][$k+1] - $p * $q;
619
						}
620
						// Accumulate transformations
621
						for ($i = $low; $i <= $high; ++$i) {
622
							$p = $x * $this->V[$i][$k] + $y * $this->V[$i][$k+1];
623
							if ($notlast) {
624
								$p = $p + $z * $this->V[$i][$k+2];
625
								$this->V[$i][$k+2] = $this->V[$i][$k+2] - $p * $r;
626
							}
627
							$this->V[$i][$k] = $this->V[$i][$k] - $p;
628
							$this->V[$i][$k+1] = $this->V[$i][$k+1] - $p * $q;
629
						}
630
					}  // ($s != 0)
631
				}  // k loop
632
			}  // check convergence
633
		}  // while ($n >= $low)
634
 
635
		// Backsubstitute to find vectors of upper triangular form
636
		if ($norm == 0.0) {
637
			return;
638
		}
639
 
640
		for ($n = $nn-1; $n >= 0; --$n) {
641
			$p = $this->d[$n];
642
			$q = $this->e[$n];
643
			// Real vector
644
			if ($q == 0) {
645
				$l = $n;
646
				$this->H[$n][$n] = 1.0;
647
				for ($i = $n-1; $i >= 0; --$i) {
648
					$w = $this->H[$i][$i] - $p;
649
					$r = 0.0;
650
					for ($j = $l; $j <= $n; ++$j) {
651
						$r = $r + $this->H[$i][$j] * $this->H[$j][$n];
652
					}
653
					if ($this->e[$i] < 0.0) {
654
						$z = $w;
655
						$s = $r;
656
					} else {
657
						$l = $i;
658
						if ($this->e[$i] == 0.0) {
659
							if ($w != 0.0) {
660
								$this->H[$i][$n] = -$r / $w;
661
							} else {
662
								$this->H[$i][$n] = -$r / ($eps * $norm);
663
							}
664
						// Solve real equations
665
						} else {
666
							$x = $this->H[$i][$i+1];
667
							$y = $this->H[$i+1][$i];
668
							$q = ($this->d[$i] - $p) * ($this->d[$i] - $p) + $this->e[$i] * $this->e[$i];
669
							$t = ($x * $s - $z * $r) / $q;
670
							$this->H[$i][$n] = $t;
671
							if (abs($x) > abs($z)) {
672
								$this->H[$i+1][$n] = (-$r - $w * $t) / $x;
673
							} else {
674
								$this->H[$i+1][$n] = (-$s - $y * $t) / $z;
675
							}
676
						}
677
						// Overflow control
678
						$t = abs($this->H[$i][$n]);
679
						if (($eps * $t) * $t > 1) {
680
							for ($j = $i; $j <= $n; ++$j) {
681
								$this->H[$j][$n] = $this->H[$j][$n] / $t;
682
							}
683
						}
684
					}
685
				}
686
			// Complex vector
687
			} else if ($q < 0) {
688
				$l = $n-1;
689
				// Last vector component imaginary so matrix is triangular
690
				if (abs($this->H[$n][$n-1]) > abs($this->H[$n-1][$n])) {
691
					$this->H[$n-1][$n-1] = $q / $this->H[$n][$n-1];
692
					$this->H[$n-1][$n] = -($this->H[$n][$n] - $p) / $this->H[$n][$n-1];
693
				} else {
694
					$this->cdiv(0.0, -$this->H[$n-1][$n], $this->H[$n-1][$n-1] - $p, $q);
695
					$this->H[$n-1][$n-1] = $this->cdivr;
696
					$this->H[$n-1][$n]   = $this->cdivi;
697
				}
698
				$this->H[$n][$n-1] = 0.0;
699
				$this->H[$n][$n] = 1.0;
700
				for ($i = $n-2; $i >= 0; --$i) {
701
					// double ra,sa,vr,vi;
702
					$ra = 0.0;
703
					$sa = 0.0;
704
					for ($j = $l; $j <= $n; ++$j) {
705
						$ra = $ra + $this->H[$i][$j] * $this->H[$j][$n-1];
706
						$sa = $sa + $this->H[$i][$j] * $this->H[$j][$n];
707
					}
708
					$w = $this->H[$i][$i] - $p;
709
					if ($this->e[$i] < 0.0) {
710
						$z = $w;
711
						$r = $ra;
712
						$s = $sa;
713
					} else {
714
						$l = $i;
715
						if ($this->e[$i] == 0) {
716
							$this->cdiv(-$ra, -$sa, $w, $q);
717
							$this->H[$i][$n-1] = $this->cdivr;
718
							$this->H[$i][$n]   = $this->cdivi;
719
						} else {
720
							// Solve complex equations
721
							$x = $this->H[$i][$i+1];
722
							$y = $this->H[$i+1][$i];
723
							$vr = ($this->d[$i] - $p) * ($this->d[$i] - $p) + $this->e[$i] * $this->e[$i] - $q * $q;
724
							$vi = ($this->d[$i] - $p) * 2.0 * $q;
725
							if ($vr == 0.0 & $vi == 0.0) {
726
								$vr = $eps * $norm * (abs($w) + abs($q) + abs($x) + abs($y) + abs($z));
727
							}
728
							$this->cdiv($x * $r - $z * $ra + $q * $sa, $x * $s - $z * $sa - $q * $ra, $vr, $vi);
729
							$this->H[$i][$n-1] = $this->cdivr;
730
							$this->H[$i][$n]   = $this->cdivi;
731
							if (abs($x) > (abs($z) + abs($q))) {
732
								$this->H[$i+1][$n-1] = (-$ra - $w * $this->H[$i][$n-1] + $q * $this->H[$i][$n]) / $x;
733
								$this->H[$i+1][$n] = (-$sa - $w * $this->H[$i][$n] - $q * $this->H[$i][$n-1]) / $x;
734
							} else {
735
								$this->cdiv(-$r - $y * $this->H[$i][$n-1], -$s - $y * $this->H[$i][$n], $z, $q);
736
								$this->H[$i+1][$n-1] = $this->cdivr;
737
								$this->H[$i+1][$n]   = $this->cdivi;
738
							}
739
						}
740
						// Overflow control
741
						$t = max(abs($this->H[$i][$n-1]),abs($this->H[$i][$n]));
742
						if (($eps * $t) * $t > 1) {
743
							for ($j = $i; $j <= $n; ++$j) {
744
								$this->H[$j][$n-1] = $this->H[$j][$n-1] / $t;
745
								$this->H[$j][$n]   = $this->H[$j][$n] / $t;
746
							}
747
						}
748
					} // end else
749
				} // end for
750
			} // end else for complex case
751
		} // end for
752
 
753
		// Vectors of isolated roots
754
		for ($i = 0; $i < $nn; ++$i) {
755
			if ($i < $low | $i > $high) {
756
				for ($j = $i; $j < $nn; ++$j) {
757
					$this->V[$i][$j] = $this->H[$i][$j];
758
				}
759
			}
760
		}
761
 
762
		// Back transformation to get eigenvectors of original matrix
763
		for ($j = $nn-1; $j >= $low; --$j) {
764
			for ($i = $low; $i <= $high; ++$i) {
765
				$z = 0.0;
766
				for ($k = $low; $k <= min($j,$high); ++$k) {
767
					$z = $z + $this->V[$i][$k] * $this->H[$k][$j];
768
				}
769
				$this->V[$i][$j] = $z;
770
			}
771
		}
772
	} // end hqr2
773
 
774
 
775
	/**
776
	 *	Constructor: Check for symmetry, then construct the eigenvalue decomposition
777
	 *
778
	 *	@access public
779
	 *	@param A  Square matrix
780
	 *	@return Structure to access D and V.
781
	 */
782
	public function __construct($Arg) {
783
		$this->A = $Arg->getArray();
784
		$this->n = $Arg->getColumnDimension();
785
 
786
		$issymmetric = true;
787
		for ($j = 0; ($j < $this->n) & $issymmetric; ++$j) {
788
			for ($i = 0; ($i < $this->n) & $issymmetric; ++$i) {
789
				$issymmetric = ($this->A[$i][$j] == $this->A[$j][$i]);
790
			}
791
		}
792
 
793
		if ($issymmetric) {
794
			$this->V = $this->A;
795
			// Tridiagonalize.
796
			$this->tred2();
797
			// Diagonalize.
798
			$this->tql2();
799
		} else {
800
			$this->H = $this->A;
801
			$this->ort = array();
802
			// Reduce to Hessenberg form.
803
			$this->orthes();
804
			// Reduce Hessenberg to real Schur form.
805
			$this->hqr2();
806
		}
807
	}
808
 
809
 
810
	/**
811
	 *	Return the eigenvector matrix
812
	 *
813
	 *	@access public
814
	 *	@return V
815
	 */
816
	public function getV() {
817
		return new Matrix($this->V, $this->n, $this->n);
818
	}
819
 
820
 
821
	/**
822
	 *	Return the real parts of the eigenvalues
823
	 *
824
	 *	@access public
825
	 *	@return real(diag(D))
826
	 */
827
	public function getRealEigenvalues() {
828
		return $this->d;
829
	}
830
 
831
 
832
	/**
833
	 *	Return the imaginary parts of the eigenvalues
834
	 *
835
	 *	@access public
836
	 *	@return imag(diag(D))
837
	 */
838
	public function getImagEigenvalues() {
839
		return $this->e;
840
	}
841
 
842
 
843
	/**
844
	 *	Return the block diagonal eigenvalue matrix
845
	 *
846
	 *	@access public
847
	 *	@return D
848
	 */
849
	public function getD() {
850
		for ($i = 0; $i < $this->n; ++$i) {
851
			$D[$i] = array_fill(0, $this->n, 0.0);
852
			$D[$i][$i] = $this->d[$i];
853
			if ($this->e[$i] == 0) {
854
				continue;
855
			}
856
			$o = ($this->e[$i] > 0) ? $i + 1 : $i - 1;
857
			$D[$i][$o] = $this->e[$i];
858
		}
859
		return new Matrix($D);
860
	}
861
 
862
}	//	class EigenvalueDecomposition