예제 #1
0
 /**
  * Only eigenvalues of a symmetric real matrix are computed.
  *
  * @param A a symmetric real matrix
  * @return a 1D {@code double} array containing the eigenvalues in decreasing order (absolute
  *     value)
  */
 public static double[] computeEigenvalues(Matrix A) {
   SparseMatrix S = (SparseMatrix) decompose(A, false)[1];
   int m = S.getRowDimension();
   int n = S.getColumnDimension();
   int len = m >= n ? n : m;
   double[] s = ArrayOperator.allocateVector(len, 0);
   for (int i = 0; i < len; i++) {
     s[i] = S.getEntry(i, i);
   }
   return s;
 }
예제 #2
0
  /**
   * Do eigenvalue decomposition for a real symmetric tridiagonal matrix, i.e. T = VDV'.
   *
   * @param T a real symmetric tridiagonal matrix
   * @param computeV if V is to be computed
   * @return a {@code Matrix} array [V, D]
   */
  private static Matrix[] diagonalizeTD(Matrix T, boolean computeV) {

    int m = T.getRowDimension();
    int n = T.getColumnDimension();
    int len = m >= n ? n : m;
    int idx = 0;

    /*
     * The tridiagonal matrix T is
     * s[0] e[0]
     * e[0] s[1] e[1]
     *      e[1] ...
     *               s[len - 2] e[len - 2]
     *               e[len - 2] s[len - 1]
     */
    double[] s = ArrayOperator.allocateVector(len, 0);
    double[] e = ArrayOperator.allocateVector(len, 0);

    for (int i = 0; i < len - 1; i++) {
      s[i] = T.getEntry(i, i);
      e[i] = T.getEntry(i, i + 1);
    }
    s[len - 1] = T.getEntry(len - 1, len - 1);

    // V': each row of V' is a right singular vector
    double[][] Vt = null;
    if (computeV) Vt = eye(n, n).getData();

    double[] mu = ArrayOperator.allocate1DArray(len, 0);

    /*
     * T0 = ITI', V = I
     * T = IT0I' = VT0G1G1'Vt = VT0G1(G1'Vt)
     *   = VG1G1'T0G1(G1'Vt) = (VG1)(G1'T0G1)(G1'Vt)
     *   = (VG1)T1(G1'Vt)
     *   ...
     *   = (Gn-1...G2G1)D(G1G2...Gn-1)'
     *
     * where G = |cs  sn|
     *           |-sn cs|
     * G' = |cs -sn|
     *      |sn  cs|
     */

    /*
     * Find B_hat, i.e. the bottommost unreduced submatrix of B.
     * Index starts from 0.
     */
    // *********************************************************

    int i_start = 0;
    int i_end = len - 1;
    // int cnt_shifted = 0;
    int ind = 1;
    while (true) {

      idx = len - 2;
      while (idx >= 0) {
        if (e[idx] == 0) {
          idx--;
        } else {
          break;
        }
      }
      i_end = idx + 1;
      // Now idx = -1 or e[idx] != 0
      // If idx = -1, then e[0] = 0, i_start = i_end = 0, e = 0
      // Else if e[idx] != 0, then e[i] = 0 for i_end = idx + 1 <= i <= len - 1
      while (idx >= 0) {
        if (e[idx] != 0) {
          idx--;
        } else {
          break;
        }
      }
      i_start = idx + 1;
      // Now idx = -1 or e[idx] = 0
      // If idx = -1 i_start = 0
      // Else if e[idx] = 0, then e[idx + 1] != 0, e[i_end - 1] != 0
      // i.e. e[i] != 0 for i_start <= i <= i_end - 1

      if (i_start == i_end) {
        break;
      }

      // Apply the stopping criterion to B_hat
      // If any e[i] is set to zero, return to loop

      boolean set2Zero = false;
      mu[i_start] = abs(s[i_start]);
      for (int j = i_start; j < i_end; j++) {
        mu[j + 1] = abs(s[j + 1]) * mu[j] / (mu[j] + abs(e[j]));
        if (abs(e[j]) <= mu[j] * tol) {
          e[j] = 0;
          set2Zero = true;
        }
      }
      if (set2Zero) {
        continue;
      }

      implicitSymmetricShiftedQR(s, e, Vt, i_start, i_end, computeV);
      // cnt_shifted++;

      if (ind == maxIter) {
        break;
      }

      ind++;
    }

    // fprintf("cnt_shifted: %d\n", cnt_shifted);
    // *********************************************************

    // Quick sort eigenvalues and eigenvectors
    quickSort(s, Vt, 0, len - 1, "descend", computeV);

    Matrix[] VD = new Matrix[2];
    VD[0] = computeV ? new DenseMatrix(Vt).transpose() : null;
    VD[1] = buildD(s, m, n);

    /*disp("T:");
    printMatrix(T);
    disp("VDV':");
    Matrix V = VD[0];
    Matrix D = VD[1];
    disp(V.mtimes(D).mtimes(V.transpose()));*/

    return VD;
  }
예제 #3
0
  /**
   * Tridiagonalize a real symmetric matrix A, i.e. A = Q * T * Q' such that Q is an orthogonal
   * matrix and T is a tridiagonal matrix.
   *
   * <p>A = QTQ' <=> Q'AQ = T
   *
   * @param A a real symmetric matrix
   * @param computeV if V is to be computed
   * @return a {@code Matrix} array [Q, T]
   */
  private static Matrix[] tridiagonalize(Matrix A, boolean computeV) {
    A = full(A).copy();
    int m = A.getRowDimension();
    int n = A.getColumnDimension();
    Matrix[] QT = new Matrix[2];
    double[] a = ArrayOperator.allocateVector(n, 0);
    double[] b = ArrayOperator.allocateVector(n, 0);
    double[][] AData = ((DenseMatrix) A).getData();
    double c = 0;
    double s = 0;
    double r = 0;
    for (int j = 0; j < n - 2; j++) {
      a[j] = AData[j][j];
      // Householder transformation on columns of A(j+1:m, j+1:n)
      // Compute the norm of A(j+1:m, j)
      c = 0;
      for (int i = j + 1; i < m; i++) {
        c += Math.pow(AData[i][j], 2);
      }
      if (c == 0) continue;
      s = Math.sqrt(c);
      b[j] = AData[j + 1][j] > 0 ? -s : s;
      r = Math.sqrt(s * (s + abs(AData[j + 1][j])));

      /*double[] u1 = ArrayOperation.allocate1DArray(n, 0);
      for (int k = j + 1; k < m; k++) {
      	u1[k] = AData[k][j];
      }
      u1[j + 1] -= b[j];
      for (int k = j + 1; k < m; k++) {
      	u1[k] /= r;
      }
      Matrix H = eye(n).minus(new DenseMatrix(u1, 1).mtimes(new DenseMatrix(u1, 2)));
      disp(new DenseMatrix(u1, 1));
      disp(eye(n));
      disp(H);
      disp(A);
      disp(H.mtimes(A).mtimes(H));
      disp(A);*/

      AData[j + 1][j] -= b[j];
      for (int k = j + 1; k < m; k++) {
        AData[k][j] /= r;
      }

      double[] w = new double[n - j - 1];
      double[] u = new double[n - j - 1];
      double[] v = new double[n - j - 1];

      for (int i = j + 1, t = 0; i < m; i++, t++) {
        u[t] = AData[i][j];
      }

      // v = B33 * u
      for (int i = j + 1, t = 0; i < m; i++, t++) {
        double[] ARow_i = AData[i];
        s = 0;
        for (int k = j + 1, l = 0; k < n; k++, l++) {
          s += ARow_i[k] * u[l];
        }
        v[t] = s;
      }

      c = ArrayOperator.innerProduct(u, v) / 2;
      for (int i = j + 1, t = 0; i < m; i++, t++) {
        w[t] = v[t] - c * u[t];
      }

      /*disp(w);
      Matrix B33 = new DenseMatrix(n - j - 1, n - j - 1, 0);
      for (int i = j + 1, t = 0; i < m; i++, t++) {
      	double[] ARow_i = AData[i];
      	for (int k = j + 1, l = 0; k < n; k++, l++) {
      		B33.setEntry(t, l, ARow_i[k]);
      	}
      }
      disp(B33);
      Matrix U = new DenseMatrix(u, 1);
      disp(U.transpose().mtimes(U));
      disp(U);
      Matrix W = B33.mtimes(U).minus(U);
      disp(W);
      disp(B33.minus(plus(U.mtimes(W.transpose()), W.mtimes(U.transpose()))));
      Matrix Hk = eye(n - j - 1).minus(U.mtimes(U.transpose()));
      disp(Hk);
      disp(Hk.mtimes(B33).mtimes(Hk));*/
      for (int i = j + 1, t = 0; i < m; i++, t++) {
        double[] ARow_i = AData[i];
        for (int k = j + 1, l = 0; k < n; k++, l++) {
          ARow_i[k] = ARow_i[k] - (u[t] * w[l] + w[t] * u[l]);
        }
      }
      // disp(A);

      /*fprintf("Householder transformation on n - 1 columns:\n");
      disp(A);*/
      // disp(A);
      // Householder transformation on rows of A(j:m, j+1:n)

    }
    a[n - 2] = AData[n - 2][n - 2];
    a[n - 1] = AData[n - 1][n - 1];
    b[n - 2] = AData[n - 1][n - 2];
    QT = unpack(A, a, b, computeV);
    return QT;
  }