hierarchy R computing

Author: hhbyyh

mllib/src/main/scala/org/apache/spark/mllib/linalg/distributed/RowMatrix.scala

@@ -510,32 +510,33 @@ class RowMatrix(
   def tallSkinnyQR(computeQ: Boolean = false): QRDecomposition[RowMatrix, Matrix] = {
     val col = numCols().toInt
     // split rows horizontally into smaller matrices, and compute QR for each of them
-    val blockQRs = rows.glom().map{ partRows =>
+    val blockQRs = rows.glom().map { partRows =>
       val bdm = BDM.zeros[Double](partRows.length, col)
       var i = 0
-      partRows.foreach{ row =>
+      partRows.foreach { row =>
         bdm(i, ::) := row.toBreeze.t
         i += 1
       }
       breeze.linalg.qr.reduced(bdm).r
-    }.cache()
+    }
 
     // combine the R part from previous results vertically into a tall matrix
-    val combinedR = blockQRs.treeReduce((r1, r2) => BDM.vertcat(r1, r2))
+    val combinedR = blockQRs.treeReduce{ (r1, r2) =>
+      val partialR = BDM.vertcat(r1, r2)
+      breeze.linalg.qr.reduced(partialR).r
+    }
     val breezeR = breeze.linalg.qr.reduced(combinedR).r.toDenseMatrix
     val finalR = Matrices.fromBreeze(breezeR)
     val finalQ = if (computeQ) {
       try {
         val invR = inv(breezeR)
         this.multiply(Matrices.fromBreeze(invR))
-      }
-      catch {
+      } catch {
         case err: MatrixSingularException =>
           logWarning("R is not invertible and return Q as null")
           null
       }
-    }
-    else {
+    } else {
       null
     }
     QRDecomposition(finalQ, finalR)

mllib/src/test/scala/org/apache/spark/mllib/linalg/distributed/RowMatrixSuite.scala

@@ -249,6 +249,10 @@ class RowMatrixSuite extends SparkFunSuite with MLlibTestSparkContext {
       assert(closeToZero(abs(expected.q) - abs(calcQ.toBreeze())))
       assert(closeToZero(abs(expected.r) - abs(calcR.toBreeze.asInstanceOf[BDM[Double]])))
       assert(closeToZero(calcQ.multiply(calcR).toBreeze - mat.toBreeze()))
+      // Decomposition without computing Q
+      val rOnly = mat.tallSkinnyQR(computeQ = false)
+      assert(rOnly.Q == null)
+      assert(closeToZero(abs(expected.r) - abs(rOnly.R.toBreeze.asInstanceOf[BDM[Double]])))
     }
   }
 }