Author: erans
Date: Fri Aug 12 22:37:29 2011
New Revision: 1157280
URL: http://svn.apache.org/viewvc?rev=1157280&view=rev
Log:
Code cleanup: Removed unnecessary parentheses, empty lines.
Bitwise operator replaced by logical one.
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SingularValueDecompositionImpl.java
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SingularValueDecompositionImpl.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SingularValueDecompositionImpl.java?rev=1157280&r1=1157279&r2=1157280&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SingularValueDecompositionImpl.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SingularValueDecompositionImpl.java
Fri Aug 12 22:37:29 2011
@@ -34,37 +34,26 @@ import org.apache.commons.math.util.Fast
* @since 2.0
*/
public class SingularValueDecompositionImpl implements
SingularValueDecomposition {
-
/** Relative threshold for small singular values. */
private static final double EPS = 0x1.0p-52;
-
/** Absolute threshold for small singular values. */
private static final double TINY = 0x1.0p-966;
-
/** Computed singular values. */
private final double[] singularValues;
-
/** max(row dimension, column dimension). */
private final int m;
-
/** min(row dimension, column dimension). */
private final int n;
-
/** Indicator for transposed matrix. */
private final boolean transposed;
-
/** Cached value of U matrix. */
private final RealMatrix cachedU;
-
/** Cached value of transposed U matrix. */
private RealMatrix cachedUt;
-
/** Cached value of S (diagonal) matrix. */
private RealMatrix cachedS;
-
/** Cached value of V matrix. */
private final RealMatrix cachedV;
-
/** Cached value of transposed V matrix. */
private RealMatrix cachedVt;
@@ -122,7 +111,8 @@ public class SingularValueDecompositionI
singularValues[k] = -singularValues[k];
}
for (int j = k + 1; j < n; j++) {
- if ((k < nct) && (singularValues[k] != 0.0)) {
+ if (k < nct &&
+ singularValues[k] != 0.0) {
// Apply the transformation.
double t = 0;
for (int i = k; i < m; i++) {
@@ -137,7 +127,8 @@ public class SingularValueDecompositionI
// subsequent calculation of the row transformation.
e[j] = A[k][j];
}
- if (wantu && (k < nct)) {
+ if (wantu &&
+ k < nct) {
// Place the transformation in U for subsequent back
// multiplication.
for (int i = k; i < m; i++) {
@@ -162,7 +153,8 @@ public class SingularValueDecompositionI
e[k + 1] += 1.0;
}
e[k] = -e[k];
- if ((k + 1 < m) && (e[k] != 0.0)) {
+ if (k + 1 < m &&
+ e[k] != 0) {
// Apply the transformation.
for (int i = k + 1; i < m; i++) {
work[i] = 0.0;
@@ -238,7 +230,8 @@ public class SingularValueDecompositionI
// If required, generate V.
if (wantv) {
for (int k = n - 1; k >= 0; k--) {
- if ((k < nrt) && (e[k] != 0.0)) {
+ if (k < nrt &&
+ e[k] != 0) {
for (int j = k + 1; j < nu; j++) {
double t = 0;
for (int i = k + 1; i < n; i++) {
@@ -368,7 +361,8 @@ public class SingularValueDecompositionI
final double b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1)
/ 2.0;
final double c = (sp * epm1) * (sp * epm1);
double shift = 0.0;
- if ((b != 0.0) | (c != 0.0)) {
+ if (b != 0 ||
+ c != 0) {
shift = FastMath.sqrt(b * b + c);
if (b < 0.0) {
shift = -shift;
@@ -404,7 +398,8 @@ public class SingularValueDecompositionI
singularValues[j + 1] = -sn * e[j] + cs *
singularValues[j + 1];
g = sn * e[j + 1];
e[j + 1] = cs * e[j + 1];
- if (wantu && (j < m - 1)) {
+ if (wantu &&
+ j < m - 1) {
for (int i = 0; i < m; i++) {
t = cs * U[i][j] + sn * U[i][j + 1];
U[i][j + 1] = -sn * U[i][j] + cs * U[i][j + 1];
@@ -435,14 +430,16 @@ public class SingularValueDecompositionI
double t = singularValues[k];
singularValues[k] = singularValues[k + 1];
singularValues[k + 1] = t;
- if (wantv && (k < n - 1)) {
+ if (wantv &&
+ k < n - 1) {
for (int i = 0; i < n; i++) {
t = V[i][k + 1];
V[i][k + 1] = V[i][k];
V[i][k] = t;
}
}
- if (wantu && (k < m - 1)) {
+ if (wantu &&
+ k < m - 1) {
for (int i = 0; i < m; i++) {
t = U[i][k + 1];
U[i][k + 1] = U[i][k];
@@ -518,7 +515,8 @@ public class SingularValueDecompositionI
// get the number of singular values to consider
final int p = singularValues.length;
int dimension = 0;
- while ((dimension < p) && (singularValues[dimension] >=
minSingularValue)) {
+ while (dimension < p &&
+ singularValues[dimension] >= minSingularValue) {
++dimension;
}
