Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * Copyright 1999 CERN - European Organization for Nuclear Research.
  * Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
  * is hereby granted without fee, provided that the above copyright notice appear in all copies and
  * that both that copyright notice and this permission notice appear in supporting documentation.
  * CERN makes no representations about the suitability of this software for any purpose.
  * It is provided "as is" without expressed or implied warranty.
  */
 package org.apache.mahout.math;
 
 
For an m x n matrix A with m >= n, the QR decomposition is an m x n orthogonal matrix Q and an n x n upper triangular matrix R so that A = Q*R.

The QR decompostion always exists, even if the matrix does not have full rank, so the constructor will never fail. The primary use of the QR decomposition is in the least squares solution of nonsquare systems of simultaneous linear equations. This will fail if isFullRank() returns false.

 
 
 public class QRDecomposition implements QR {
   private final Matrix q;
   private final Matrix r;
   private final boolean fullRank;
   private final int rows;
   private final int columns;

  
Constructs and returns a new QR decomposition object; computed by Householder reflections; The decomposed matrices can be retrieved via instance methods of the returned decomposition object.

Parameters:
a A rectangular matrix.
Throws:
java.lang.IllegalArgumentException if A.rows() < A.columns().
 
   public QRDecomposition(Matrix a) {
 
      = a.rowSize();
     int min = Math.min(a.rowSize(), a.columnSize());
      = a.columnSize();
 
     Matrix qTmp = a.clone();
 
     boolean fullRank = true;
 
      = new DenseMatrix(min);
 
     for (int i = 0; i < mini++) {
       Vector qi = qTmp.viewColumn(i);
       double alpha = qi.norm(2);
       if (Math.abs(alpha) > .) {
         qi.assign(Functions.div(alpha));
       } else {
         if (Double.isInfinite(alpha) || Double.isNaN(alpha)) {
           throw new ArithmeticException("Invalid intermediate result");
         }
         fullRank = false;
       }
       .set(iialpha);
 
       for (int j = i + 1; j < j++) {
         Vector qj = qTmp.viewColumn(j);
         double norm = qj.norm(2);
         if (Math.abs(norm) > .) {
           double beta = qi.dot(qj);
           .set(ijbeta);
           if (j < min) {
             qj.assign(qi, Functions.plusMult(-beta));
           }
         } else {
           if (Double.isInfinite(norm) || Double.isNaN(norm)) {
             throw new ArithmeticException("Invalid intermediate result");
           }
         }
       }
     }
     if ( > min) {
       = qTmp.viewPart(0, , 0, min).clone();
    } else {
       = qTmp;
    }
    this. = fullRank;
  }

  
Generates and returns the (economy-sized) orthogonal factor Q.

Returns:
Q
  public Matrix getQ() {
    return ;
  }

  
Returns the upper triangular factor, R.

Returns:
R
  public Matrix getR() {
    return ;
  }

  
Returns whether the matrix A has full rank.

Returns:
true if R, and hence A, has full rank.
  public boolean hasFullRank() {
    return ;
  }

  
Least squares solution of A*X = B; returns X.

Parameters:
B A matrix with as many rows as A and any number of columns.
Returns:
X that minimizes the two norm of Q*R*X - B.
Throws:
java.lang.IllegalArgumentException if B.rows() != A.rows().
  public Matrix solve(Matrix B) {
    if (B.numRows() != ) {
      throw new IllegalArgumentException("Matrix row dimensions must agree.");
    }
    int cols = B.numCols();
    Matrix x = B.like(cols);
    // this can all be done a bit more efficiently if we don't actually
    // form explicit versions of Q^T and R but this code isn't soo bad
    // and it is much easier to understand
    Matrix qt = getQ().transpose();
    Matrix y = qt.times(B);
    Matrix r = getR();
    for (int k = Math.min() - 1; k >= 0; k--) {
      // X[k,] = Y[k,] / R[k,k], note that X[k,] starts with 0 so += is same as =
      x.viewRow(k).assign(y.viewRow(k), Functions.plusMult(1 / r.get(kk)));
      // Y[0:(k-1),] -= R[0:(k-1),k] * X[k,]
      Vector rColumn = r.viewColumn(k).viewPart(0, k);
      for (int c = 0; c < colsc++) {
        y.viewColumn(c).viewPart(0, k).assign(rColumn, Functions.plusMult(-x.get(kc)));
      }
    }
    return x;
  }

  
Returns a rough string rendition of a QR.
  public String toString() {
    return String.format(."QR(%d x %d,fullRank=%s)"hasFullRank());
  }
New to GrepCode? Check out our FAQ X