http://git-wip-us.apache.org/repos/asf/systemml/blob/1f323976/src/main/java/org/apache/sysml/runtime/matrix/data/FrameBlock.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/FrameBlock.java b/src/main/java/org/apache/sysml/runtime/matrix/data/FrameBlock.java index ff720a2..87c6aca 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/FrameBlock.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/FrameBlock.java @@ -793,17 +793,13 @@ public class FrameBlock implements Writable, CacheBlock, Externalizable /////// // indexing and append operations - public FrameBlock leftIndexingOperations(FrameBlock rhsFrame, IndexRange ixrange, FrameBlock ret) - throws DMLRuntimeException - { + public FrameBlock leftIndexingOperations(FrameBlock rhsFrame, IndexRange ixrange, FrameBlock ret) { return leftIndexingOperations(rhsFrame, (int)ixrange.rowStart, (int)ixrange.rowEnd, (int)ixrange.colStart, (int)ixrange.colEnd, ret); } - public FrameBlock leftIndexingOperations(FrameBlock rhsFrame, int rl, int ru, int cl, int cu, FrameBlock ret) - throws DMLRuntimeException - { + public FrameBlock leftIndexingOperations(FrameBlock rhsFrame, int rl, int ru, int cl, int cu, FrameBlock ret) { // check the validity of bounds if ( rl < 0 || rl >= getNumRows() || ru < rl || ru >= getNumRows() || cl < 0 || cu >= getNumColumns() || cu < cl || cu >= getNumColumns() ) { @@ -848,9 +844,7 @@ public class FrameBlock implements Writable, CacheBlock, Externalizable return ret; } - public FrameBlock slice(IndexRange ixrange, FrameBlock ret) - throws DMLRuntimeException - { + public FrameBlock slice(IndexRange ixrange, FrameBlock ret) { return slice( (int)ixrange.rowStart, (int)ixrange.rowEnd, (int)ixrange.colStart, (int)ixrange.colEnd, ret); @@ -866,11 +860,8 @@ public class FrameBlock implements Writable, CacheBlock, Externalizable * @param cu column upper index, inclusive, 0-based * @param retCache cache block * @return frame block - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public FrameBlock slice(int rl, int ru, int cl, int cu, CacheBlock retCache) - throws DMLRuntimeException - { + public FrameBlock slice(int rl, int ru, int cl, int cu, CacheBlock retCache) { FrameBlock ret = (FrameBlock)retCache; // check the validity of bounds if ( rl < 0 || rl >= getNumRows() || ru < rl || ru >= getNumRows() @@ -966,11 +957,8 @@ public class FrameBlock implements Writable, CacheBlock, Externalizable * @param ret frame block to return, can be null * @param cbind if true, column append * @return frame block - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public FrameBlock append( FrameBlock that, FrameBlock ret, boolean cbind ) - throws DMLRuntimeException - { + public FrameBlock append( FrameBlock that, FrameBlock ret, boolean cbind ) { if( cbind ) //COLUMN APPEND { //sanity check row dimension mismatch @@ -1087,15 +1075,11 @@ public class FrameBlock implements Writable, CacheBlock, Externalizable return map; } - public void merge(CacheBlock that, boolean bDummy) - throws DMLRuntimeException - { + public void merge(CacheBlock that, boolean bDummy) { merge((FrameBlock)that); } - public void merge(FrameBlock that) - throws DMLRuntimeException - { + public void merge(FrameBlock that) { //check for empty input source (nothing to merge) if( that == null || that.getNumRows() == 0 ) return; @@ -1140,11 +1124,8 @@ public class FrameBlock implements Writable, CacheBlock, Externalizable * @param brlen ? * @param iMaxRowsToCopy ? * @return frame block - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public FrameBlock zeroOutOperations(FrameBlock result, IndexRange range, boolean complementary, int iRowStartSrc, int iRowStartDest, int brlen, int iMaxRowsToCopy) - throws DMLRuntimeException - { + public FrameBlock zeroOutOperations(FrameBlock result, IndexRange range, boolean complementary, int iRowStartSrc, int iRowStartDest, int brlen, int iMaxRowsToCopy) { int clen = getNumColumns(); if(result==null)
http://git-wip-us.apache.org/repos/asf/systemml/blob/1f323976/src/main/java/org/apache/sysml/runtime/matrix/data/InputInfo.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/InputInfo.java b/src/main/java/org/apache/sysml/runtime/matrix/data/InputInfo.java index e736b43..2bbad62 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/InputInfo.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/InputInfo.java @@ -83,7 +83,7 @@ public class InputInfo implements Serializable public static final InputInfo CSVInputInfo=new InputInfo(TextInputFormat.class, LongWritable.class, Text.class); - public static OutputInfo getMatchingOutputInfo(InputInfo ii) throws DMLRuntimeException { + public static OutputInfo getMatchingOutputInfo(InputInfo ii) { if ( ii == InputInfo.BinaryBlockInputInfo ) return OutputInfo.BinaryBlockOutputInfo; else if ( ii == InputInfo.MatrixMarketInputInfo) @@ -140,9 +140,7 @@ public class InputInfo implements Serializable return null; } - public static String inputInfoToString (InputInfo ii) - throws DMLRuntimeException - { + public static String inputInfoToString (InputInfo ii) { if ( ii == TextCellInputInfo ) return "textcell"; else if ( ii == BinaryCellInputInfo ) http://git-wip-us.apache.org/repos/asf/systemml/blob/1f323976/src/main/java/org/apache/sysml/runtime/matrix/data/LibCommonsMath.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibCommonsMath.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibCommonsMath.java index 2755c28..4efc3aa 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibCommonsMath.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibCommonsMath.java @@ -56,9 +56,7 @@ public class LibCommonsMath return ( opcode.equals("solve") ); } - public static MatrixBlock unaryOperations(MatrixObject inj, String opcode) - throws DMLRuntimeException - { + public static MatrixBlock unaryOperations(MatrixObject inj, String opcode) { Array2DRowRealMatrix matrixInput = DataConverter.convertToArray2DRowRealMatrix(inj); if(opcode.equals("inverse")) return computeMatrixInverse(matrixInput); @@ -67,9 +65,7 @@ public class LibCommonsMath return null; } - public static MatrixBlock[] multiReturnOperations(MatrixObject in, String opcode) - throws DMLRuntimeException - { + public static MatrixBlock[] multiReturnOperations(MatrixObject in, String opcode) { if(opcode.equals("qr")) return computeQR(in); else if (opcode.equals("lu")) @@ -81,9 +77,7 @@ public class LibCommonsMath return null; } - public static MatrixBlock matrixMatrixOperations(MatrixObject in1, MatrixObject in2, String opcode) - throws DMLRuntimeException - { + public static MatrixBlock matrixMatrixOperations(MatrixObject in1, MatrixObject in2, String opcode) { if(opcode.equals("solve")) return computeSolve(in1, in2); return null; @@ -95,11 +89,8 @@ public class LibCommonsMath * @param in1 matrix object 1 * @param in2 matrix object 2 * @return matrix block - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static MatrixBlock computeSolve(MatrixObject in1, MatrixObject in2) - throws DMLRuntimeException - { + private static MatrixBlock computeSolve(MatrixObject in1, MatrixObject in2) { Array2DRowRealMatrix matrixInput = DataConverter.convertToArray2DRowRealMatrix(in1); Array2DRowRealMatrix vectorInput = DataConverter.convertToArray2DRowRealMatrix(in2); @@ -121,11 +112,8 @@ public class LibCommonsMath * * @param in matrix object * @return array of matrix blocks - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static MatrixBlock[] computeQR(MatrixObject in) - throws DMLRuntimeException - { + private static MatrixBlock[] computeQR(MatrixObject in) { Array2DRowRealMatrix matrixInput = DataConverter.convertToArray2DRowRealMatrix(in); // Perform QR decomposition @@ -145,11 +133,8 @@ public class LibCommonsMath * * @param in matrix object * @return array of matrix blocks - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static MatrixBlock[] computeLU(MatrixObject in) - throws DMLRuntimeException - { + private static MatrixBlock[] computeLU(MatrixObject in) { if ( in.getNumRows() != in.getNumColumns() ) { throw new DMLRuntimeException("LU Decomposition can only be done on a square matrix. Input matrix is rectangular (rows=" + in.getNumRows() + ", cols="+ in.getNumColumns() +")"); } @@ -176,11 +161,8 @@ public class LibCommonsMath * * @param in matrix object * @return array of matrix blocks - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static MatrixBlock[] computeEigen(MatrixObject in) - throws DMLRuntimeException - { + private static MatrixBlock[] computeEigen(MatrixObject in) { if ( in.getNumRows() != in.getNumColumns() ) { throw new DMLRuntimeException("Eigen Decomposition can only be done on a square matrix. Input matrix is rectangular (rows=" + in.getNumRows() + ", cols="+ in.getNumColumns() +")"); } @@ -230,9 +212,8 @@ public class LibCommonsMath * * @param in Input matrix * @return An array containing U, Sigma & V - * @throws DMLRuntimeException */ - private static MatrixBlock[] computeSvd(MatrixObject in) throws DMLRuntimeException { + private static MatrixBlock[] computeSvd(MatrixObject in) { Array2DRowRealMatrix matrixInput = DataConverter.convertToArray2DRowRealMatrix(in); SingularValueDecomposition svd = new SingularValueDecomposition(matrixInput); @@ -252,11 +233,8 @@ public class LibCommonsMath * * @param in commons-math3 Array2DRowRealMatrix * @return matrix block - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static MatrixBlock computeMatrixInverse(Array2DRowRealMatrix in) - throws DMLRuntimeException - { + private static MatrixBlock computeMatrixInverse(Array2DRowRealMatrix in) { if ( !in.isSquare() ) throw new DMLRuntimeException("Input to inv() must be square matrix -- given: a " + in.getRowDimension() + "x" + in.getColumnDimension() + " matrix."); @@ -273,18 +251,13 @@ public class LibCommonsMath * * @param in commons-math3 Array2DRowRealMatrix * @return matrix block - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static MatrixBlock computeCholesky(Array2DRowRealMatrix in) - throws DMLRuntimeException - { + private static MatrixBlock computeCholesky(Array2DRowRealMatrix in) { if ( !in.isSquare() ) throw new DMLRuntimeException("Input to cholesky() must be square matrix -- given: a " + in.getRowDimension() + "x" + in.getColumnDimension() + " matrix."); - CholeskyDecomposition cholesky = new CholeskyDecomposition(in, 1e-14, CholeskyDecomposition.DEFAULT_ABSOLUTE_POSITIVITY_THRESHOLD); RealMatrix rmL = cholesky.getL(); - return DataConverter.convertToMatrixBlock(rmL.getData()); } } http://git-wip-us.apache.org/repos/asf/systemml/blob/1f323976/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixAgg.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixAgg.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixAgg.java index 85d5654..f99accb 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixAgg.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixAgg.java @@ -118,11 +118,8 @@ public class LibMatrixAgg * @param in input matrix * @param aggVal current aggregate values (in/out) * @param aggCorr current aggregate correction (in/out) - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public static void aggregateBinaryMatrix(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) - throws DMLRuntimeException - { + public static void aggregateBinaryMatrix(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) { //Timing time = new Timing(true); //boolean saggVal = aggVal.sparse, saggCorr = aggCorr.sparse; //long naggVal = aggVal.nonZeros, naggCorr = aggCorr.nonZeros; @@ -154,11 +151,8 @@ public class LibMatrixAgg * @param in matrix block * @param aggVal aggregate operator * @param aop aggregate operator - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public static void aggregateBinaryMatrix(MatrixBlock in, MatrixBlock aggVal, AggregateOperator aop) - throws DMLRuntimeException - { + public static void aggregateBinaryMatrix(MatrixBlock in, MatrixBlock aggVal, AggregateOperator aop) { //sanity check matching dimensions if( in.getNumRows()!=aggVal.getNumRows() || in.getNumColumns()!=aggVal.getNumColumns() ) throw new DMLRuntimeException("Dimension mismatch on aggregate: "+in.getNumRows()+"x"+in.getNumColumns()+ @@ -182,9 +176,7 @@ public class LibMatrixAgg // "("+aggVal.getNonZeros()+","+aggVal.isInSparseFormat()+") in "+time.stop()+"ms."); } - public static void aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop) - throws DMLRuntimeException - { + public static void aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop) { //prepare meta data AggType aggtype = getAggType(uaop); final int m = in.rlen; @@ -215,9 +207,7 @@ public class LibMatrixAgg //System.out.println("uagg ("+in.rlen+","+in.clen+","+in.sparse+") in "+time.stop()+"ms."); } - public static void aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop, int k) - throws DMLRuntimeException - { + public static void aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop, int k) { //fall back to sequential version if necessary if( k <= 1 || (long)in.nonZeros < PAR_NUMCELL_THRESHOLD || in.rlen <= k/2 || (!(uaop.indexFn instanceof ReduceCol) && out.clen*8*k > PAR_INTERMEDIATE_SIZE_THRESHOLD ) || @@ -277,9 +267,7 @@ public class LibMatrixAgg //System.out.println("uagg k="+k+" ("+in.rlen+","+in.clen+","+in.sparse+") in "+time.stop()+"ms."); } - public static MatrixBlock cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop) - throws DMLRuntimeException - { + public static MatrixBlock cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop) { //prepare meta data AggType aggtype = getAggType(uop); final int m = in.rlen; @@ -311,9 +299,7 @@ public class LibMatrixAgg return out; } - public static MatrixBlock cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop, int k) - throws DMLRuntimeException - { + public static MatrixBlock cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop, int k) { AggregateUnaryOperator uaop = InstructionUtils.parseBasicCumulativeAggregateUnaryOperator(uop); //fall back to sequential if necessary or agg not supported @@ -392,9 +378,7 @@ public class LibMatrixAgg return out; } - public static MatrixBlock aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op) - throws DMLRuntimeException - { + public static MatrixBlock aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op) { //early abort if any block is empty if( in1.isEmptyBlock(false) || in2.isEmptyBlock(false) || in3!=null&&in3.isEmptyBlock(false) ) { return ret; @@ -421,9 +405,7 @@ public class LibMatrixAgg return ret; } - public static MatrixBlock aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op, int k) - throws DMLRuntimeException - { + public static MatrixBlock aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op, int k) { //fall back to sequential version if necessary if( k <= 1 || in1.nonZeros+in2.nonZeros < PAR_NUMCELL_THRESHOLD || in1.rlen <= k/2 || (!(op.indexFn instanceof ReduceCol) && ret.clen*8*k > PAR_INTERMEDIATE_SIZE_THRESHOLD) ) { @@ -464,9 +446,7 @@ public class LibMatrixAgg return ret; } - public static void groupedAggregate(MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, Operator op) - throws DMLRuntimeException - { + public static void groupedAggregate(MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, Operator op) { if( !(op instanceof CMOperator || op instanceof AggregateOperator) ) { throw new DMLRuntimeException("Invalid operator (" + op + ") encountered while processing groupedAggregate."); } @@ -496,7 +476,6 @@ public class LibMatrixAgg } public static void groupedAggregate(MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, Operator op, int k) - throws DMLRuntimeException { //fall back to sequential version if necessary boolean rowVector = (target.getNumRows()==1 && target.getNumColumns()>1); @@ -646,9 +625,7 @@ public class LibMatrixAgg return AggType.INVALID; } - private static void aggregateFinalResult( AggregateOperator aop, MatrixBlock out, MatrixBlock partout ) - throws DMLRuntimeException - { + private static void aggregateFinalResult( AggregateOperator aop, MatrixBlock out, MatrixBlock partout ) { AggregateOperator laop = aop; //special handling for mean where the final aggregate operator (kahan plus) @@ -786,11 +763,8 @@ public class LibMatrixAgg * @param aggop aggregate operator * @param cl column lower index * @param cu column upper index - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void groupedAggregateKahanPlus( MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, AggregateOperator aggop, int cl, int cu ) - throws DMLRuntimeException - { + private static void groupedAggregateKahanPlus( MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, AggregateOperator aggop, int cl, int cu ) { boolean rowVector = (target.getNumRows()==1 && target.getNumColumns()>1); double w = 1; //default weight @@ -904,9 +878,7 @@ public class LibMatrixAgg result.appendValue(i, j+cl, buffer[i][j]._sum); } - private static void groupedAggregateCM( MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, CMOperator cmOp, int cl, int cu ) - throws DMLRuntimeException - { + private static void groupedAggregateCM( MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, CMOperator cmOp, int cl, int cu ) { CM cmFn = CM.getCMFnObject(((CMOperator) cmOp).getAggOpType()); double w = 1; //default weight @@ -974,9 +946,7 @@ public class LibMatrixAgg } } - private static void groupedAggregateVecCount( MatrixBlock groups, MatrixBlock result, int numGroups ) - throws DMLRuntimeException - { + private static void groupedAggregateVecCount( MatrixBlock groups, MatrixBlock result, int numGroups ) { //note: groups are always dense because 0 invalid if( groups.isInSparseFormat() || groups.isEmptyBlock(false) ) throw new DMLRuntimeException("Unsupported sparse input for aggregate-count on group vector."); @@ -999,9 +969,7 @@ public class LibMatrixAgg } } - private static void aggregateBinaryMatrixAllDense(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixAllDense(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) { if( in.denseBlock==null || in.isEmptyBlock(false) ) return; @@ -1035,9 +1003,7 @@ public class LibMatrixAgg aggCorr.nonZeros = nnzCC; } - private static void aggregateBinaryMatrixSparseDense(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixSparseDense(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) { if( in.isEmptyBlock(false) ) return; @@ -1081,9 +1047,7 @@ public class LibMatrixAgg aggCorr.recomputeNonZeros(); } - private static void aggregateBinaryMatrixSparseGeneric(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixSparseGeneric(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) { if( in.isEmptyBlock(false) ) return; @@ -1123,9 +1087,7 @@ public class LibMatrixAgg aggCorr.examSparsity(false); } - private static void aggregateBinaryMatrixDenseGeneric(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixDenseGeneric(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr) { if( in.denseBlock==null || in.isEmptyBlock(false) ) return; @@ -1155,9 +1117,7 @@ public class LibMatrixAgg aggCorr.examSparsity(false); } - private static void aggregateBinaryMatrixLastRowDenseGeneric(MatrixBlock in, MatrixBlock aggVal) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixLastRowDenseGeneric(MatrixBlock in, MatrixBlock aggVal) { if( in.denseBlock==null || in.isEmptyBlock(false) ) return; @@ -1185,9 +1145,7 @@ public class LibMatrixAgg aggVal.examSparsity(); } - private static void aggregateBinaryMatrixLastRowSparseGeneric(MatrixBlock in, MatrixBlock aggVal) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixLastRowSparseGeneric(MatrixBlock in, MatrixBlock aggVal) { //sparse-safe operation if( in.isEmptyBlock(false) ) return; @@ -1226,9 +1184,7 @@ public class LibMatrixAgg aggVal.examSparsity(); } - private static void aggregateBinaryMatrixLastColDenseGeneric(MatrixBlock in, MatrixBlock aggVal) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixLastColDenseGeneric(MatrixBlock in, MatrixBlock aggVal) { if( in.denseBlock==null || in.isEmptyBlock(false) ) return; @@ -1255,9 +1211,7 @@ public class LibMatrixAgg aggVal.examSparsity(); } - private static void aggregateBinaryMatrixLastColSparseGeneric(MatrixBlock in, MatrixBlock aggVal) - throws DMLRuntimeException - { + private static void aggregateBinaryMatrixLastColSparseGeneric(MatrixBlock in, MatrixBlock aggVal) { //sparse-safe operation if( in.isEmptyBlock(false) ) return; @@ -1297,9 +1251,7 @@ public class LibMatrixAgg aggVal.examSparsity(); } - private static void aggregateUnaryMatrixDense(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, IndexFunction ixFn, int rl, int ru) - throws DMLRuntimeException - { + private static void aggregateUnaryMatrixDense(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, IndexFunction ixFn, int rl, int ru) { final int n = in.clen; //note: due to corrections, even the output might be a large dense block @@ -1400,9 +1352,7 @@ public class LibMatrixAgg } } - private static void aggregateUnaryMatrixSparse(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, IndexFunction ixFn, int rl, int ru) - throws DMLRuntimeException - { + private static void aggregateUnaryMatrixSparse(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, IndexFunction ixFn, int rl, int ru) { final int m = in.rlen; final int n = in.clen; @@ -1504,9 +1454,7 @@ public class LibMatrixAgg } } - private static void cumaggregateUnaryMatrixDense(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, double[] agg, int rl, int ru) - throws DMLRuntimeException - { + private static void cumaggregateUnaryMatrixDense(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, double[] agg, int rl, int ru) { final int n = in.clen; DenseBlock da = in.getDenseBlock(); @@ -1536,9 +1484,7 @@ public class LibMatrixAgg } } - private static void cumaggregateUnaryMatrixSparse(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, double[] agg, int rl, int ru) - throws DMLRuntimeException - { + private static void cumaggregateUnaryMatrixSparse(MatrixBlock in, MatrixBlock out, AggType optype, ValueFunction vFn, double[] agg, int rl, int ru) { final int m = in.rlen; final int n = in.clen; @@ -1568,9 +1514,7 @@ public class LibMatrixAgg } } - private static MatrixBlock aggregateUnaryMatrixEmpty(MatrixBlock in, MatrixBlock out, AggType optype, IndexFunction ixFn) - throws DMLRuntimeException - { + private static MatrixBlock aggregateUnaryMatrixEmpty(MatrixBlock in, MatrixBlock out, AggType optype, IndexFunction ixFn) { //handle all full aggregates over matrices with zero rows or columns if( ixFn instanceof ReduceAll && (in.getNumRows() == 0 || in.getNumColumns() == 0) ) { double val = Double.NaN; @@ -2047,11 +1991,8 @@ public class LibMatrixAgg * calculation. * @param rl Lower row limit. * @param ru Upper row limit. - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void d_uavar(DenseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) - throws DMLRuntimeException - { + private static void d_uavar(DenseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) { final int bil = a.index(rl); final int biu = a.index(ru-1); for(int bi=bil; bi<=biu; bi++) { @@ -2081,11 +2022,8 @@ public class LibMatrixAgg * calculation. * @param rl Lower row limit. * @param ru Upper row limit. - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void d_uarvar(DenseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) - throws DMLRuntimeException - { + private static void d_uarvar(DenseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) { // calculate variance for each row for (int i=rl; i<ru; i++) { cbuff.reset(); // reset buffer for each row @@ -2113,11 +2051,8 @@ public class LibMatrixAgg * calculation. * @param rl Lower row limit. * @param ru Upper row limit. - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void d_uacvar(DenseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) - throws DMLRuntimeException - { + private static void d_uacvar(DenseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) { // calculate variance for each column incrementally for (int i=rl; i<ru; i++) varAgg(a.values(i), c, a.pos(i), n, cbuff, cm); @@ -2745,11 +2680,8 @@ public class LibMatrixAgg * calculation. * @param rl Lower row limit. * @param ru Upper row limit. - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void s_uavar(SparseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) - throws DMLRuntimeException - { + private static void s_uavar(SparseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) { // compute and store count of empty cells before aggregation int count = (ru-rl)*n - (int)a.size(rl, ru); cbuff.w = count; @@ -2784,11 +2716,8 @@ public class LibMatrixAgg * calculation. * @param rl Lower row limit. * @param ru Upper row limit. - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void s_uarvar(SparseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) - throws DMLRuntimeException - { + private static void s_uarvar(SparseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) { // calculate aggregated variance for each row for( int i=rl; i<ru; i++ ) { cbuff.reset(); // reset buffer for each row @@ -2819,11 +2748,8 @@ public class LibMatrixAgg * calculation. * @param rl Lower row limit. * @param ru Upper row limit. - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void s_uacvar(SparseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) - throws DMLRuntimeException - { + private static void s_uacvar(SparseBlock a, DenseBlock c, int n, CM_COV_Object cbuff, CM cm, int rl, int ru) { // compute and store counts of empty cells per column before aggregation // note: column results are { var | mean, count, m2 correction, mean correction } // - first, store total possible column counts in 3rd row of output @@ -2989,14 +2915,12 @@ public class LibMatrixAgg } } - private static void var(double[] a, int ai, final int len, CM_COV_Object cbuff, CM cm) throws DMLRuntimeException { + private static void var(double[] a, int ai, final int len, CM_COV_Object cbuff, CM cm) { for(int i=0; i<len; i++, ai++) cbuff = (CM_COV_Object) cm.execute(cbuff, a[ai]); } - private static void varAgg(double[] a, DenseBlock c, int ai, final int len, CM_COV_Object cbuff, CM cm) - throws DMLRuntimeException - { + private static void varAgg(double[] a, DenseBlock c, int ai, final int len, CM_COV_Object cbuff, CM cm) { //note: output might span multiple physical blocks double[] var = c.values(0); double[] mean = c.values(1); @@ -3024,7 +2948,6 @@ public class LibMatrixAgg } private static void varAgg(double[] a, DenseBlock c, int[] aix, int ai, final int len, final int n, CM_COV_Object cbuff, CM cm) - throws DMLRuntimeException { //note: output might span multiple physical blocks double[] var = c.values(0); @@ -3152,7 +3075,7 @@ public class LibMatrixAgg } @Override - public Object call() throws DMLRuntimeException { + public Object call() { if( !_in.sparse ) aggregateUnaryMatrixDense(_in, _ret, _aggtype, _uaop.aggOp.increOp.fn, _uaop.indexFn, _rl, _ru); else @@ -3170,10 +3093,8 @@ public class LibMatrixAgg private int _rl = -1; private int _ru = -1; - protected PartialAggTask( MatrixBlock in, MatrixBlock ret, AggType aggtype, AggregateUnaryOperator uaop, int rl, int ru ) - throws DMLRuntimeException - { - _in = in; + protected PartialAggTask( MatrixBlock in, MatrixBlock ret, AggType aggtype, AggregateUnaryOperator uaop, int rl, int ru ) { + _in = in; _ret = ret; _aggtype = aggtype; _uaop = uaop; @@ -3182,8 +3103,7 @@ public class LibMatrixAgg } @Override - public Object call() throws DMLRuntimeException - { + public Object call() { //thead-local allocation for partial aggregation _ret = new MatrixBlock(_ret.rlen, _ret.clen, false); _ret.allocateDenseBlock(); @@ -3214,9 +3134,7 @@ public class LibMatrixAgg private int _rl = -1; private int _ru = -1; - protected CumAggTask( MatrixBlock in, double[] agg, MatrixBlock ret, AggType aggtype, UnaryOperator uop, int rl, int ru ) - throws DMLRuntimeException - { + protected CumAggTask( MatrixBlock in, double[] agg, MatrixBlock ret, AggType aggtype, UnaryOperator uop, int rl, int ru ) { _in = in; _agg = agg; _ret = ret; @@ -3227,14 +3145,12 @@ public class LibMatrixAgg } @Override - public Long call() throws DMLRuntimeException - { + public Long call() { //compute partial cumulative aggregate if( !_in.sparse ) cumaggregateUnaryMatrixDense(_in, _ret, _aggtype, _uop.fn, _agg, _rl, _ru); else cumaggregateUnaryMatrixSparse(_in, _ret, _aggtype, _uop.fn, _agg, _rl, _ru); - //recompute partial non-zeros (ru exlusive) return _ret.recomputeNonZeros(_rl, _ru-1, 0, _ret.getNumColumns()-1); } @@ -3250,9 +3166,7 @@ public class LibMatrixAgg private final int _rl; private final int _ru; - protected AggTernaryTask( MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, IndexFunction ixFn, int rl, int ru ) - throws DMLRuntimeException - { + protected AggTernaryTask( MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, IndexFunction ixFn, int rl, int ru ) { _in1 = in1; _in2 = in2; _in3 = in3; @@ -3263,8 +3177,7 @@ public class LibMatrixAgg } @Override - public MatrixBlock call() throws DMLRuntimeException - { + public MatrixBlock call() { //thead-local allocation for partial aggregation _ret = new MatrixBlock(_ret.rlen, _ret.clen, false); _ret.allocateDenseBlock(); @@ -3292,9 +3205,7 @@ public class LibMatrixAgg private int _cl = -1; private int _cu = -1; - protected GrpAggTask( MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock ret, int numGroups, Operator op, int cl, int cu ) - throws DMLRuntimeException - { + protected GrpAggTask( MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock ret, int numGroups, Operator op, int cl, int cu ) { _groups = groups; _target = target; _weights = weights; @@ -3306,8 +3217,7 @@ public class LibMatrixAgg } @Override - public Object call() throws DMLRuntimeException - { + public Object call() { //CM operator for count, mean, variance //note: current support only for column vectors if( _op instanceof CMOperator ) { @@ -3320,7 +3230,6 @@ public class LibMatrixAgg AggregateOperator aggop = (AggregateOperator) _op; groupedAggregateKahanPlus(_groups, _target, _weights, _ret, _numGroups, aggop, _cl, _cu); } - return null; } } http://git-wip-us.apache.org/repos/asf/systemml/blob/1f323976/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixBincell.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixBincell.java b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixBincell.java index 224221b..5a93508 100644 --- a/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixBincell.java +++ b/src/main/java/org/apache/sysml/runtime/matrix/data/LibMatrixBincell.java @@ -82,11 +82,8 @@ public class LibMatrixBincell * @param m1 input matrix * @param ret result matrix * @param op scalar operator - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public static void bincellOp(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) - throws DMLRuntimeException - { + public static void bincellOp(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) { //check internal assumptions if( (op.sparseSafe && m1.isInSparseFormat()!=ret.isInSparseFormat()) ||(!op.sparseSafe && ret.isInSparseFormat()) ) { @@ -112,11 +109,8 @@ public class LibMatrixBincell * @param m2 input matrix 2 * @param ret result matrix * @param op binary operator - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public static void bincellOp(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + public static void bincellOp(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { //execute binary cell operations if(op.sparseSafe || isSparseSafeDivide(op, m2)) safeBinary(m1, m2, ret, op); @@ -135,11 +129,8 @@ public class LibMatrixBincell * @param m1ret result matrix * @param m2 matrix block * @param op binary operator - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - public static void bincellOpInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) - throws DMLRuntimeException - { + public static void bincellOpInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) { //execute binary cell operations if(op.sparseSafe || isSparseSafeDivide(op, m2)) safeBinaryInPlace(m1ret, m2, op); @@ -200,9 +191,7 @@ public class LibMatrixBincell // private sparse-safe/sparse-unsafe implementations /////////////////////////////////// - private static void safeBinary(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinary(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { boolean skipEmpty = (op.fn instanceof Multiply || isSparseSafeDivide(op, m2) ); @@ -253,9 +242,7 @@ public class LibMatrixBincell } } - private static void safeBinaryMVDense(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMVDense(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { boolean isMultiply = (op.fn instanceof Multiply); boolean skipEmpty = (isMultiply); BinaryAccessType atype = getBinaryAccessType(m1, m2); @@ -346,9 +333,7 @@ public class LibMatrixBincell ret.nonZeros = nnz; } - private static void safeBinaryMVSparse(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMVSparse(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { boolean isMultiply = (op.fn instanceof Multiply); boolean skipEmpty = (isMultiply); @@ -455,9 +440,7 @@ public class LibMatrixBincell //no need to recomputeNonZeros since maintained in append value } - private static void safeBinaryMVGeneric(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMVGeneric(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { boolean isMultiply = (op.fn instanceof Multiply); boolean skipEmpty = (isMultiply); int rlen = m1.rlen; @@ -535,9 +518,7 @@ public class LibMatrixBincell //no need to recomputeNonZeros since maintained in append value } - private static void safeBinaryVVGeneric(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryVVGeneric(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { int rlen = m1.rlen; int clen = m2.clen; @@ -563,9 +544,7 @@ public class LibMatrixBincell //no need to recomputeNonZeros since maintained in append value } - private static void safeBinaryMMSparseSparse(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMMSparseSparse(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { final int rlen = m1.rlen; if(ret.sparse) ret.allocateSparseRowsBlock(); @@ -635,9 +614,7 @@ public class LibMatrixBincell } } - private static void safeBinaryMMSparseDenseDense(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMMSparseDenseDense(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { //specific case in order to prevent binary search on sparse inputs (see quickget and quickset) ret.allocateDenseBlock(); final int n = ret.clen; @@ -719,9 +696,7 @@ public class LibMatrixBincell ret.setNonZeros(lnnz); } - private static void safeBinaryMMDenseDenseDense(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMMDenseDenseDense(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { ret.allocateDenseBlock(); DenseBlock da = m1.getDenseBlock(); DenseBlock db = m2.getDenseBlock(); @@ -743,9 +718,7 @@ public class LibMatrixBincell ret.setNonZeros(lnnz); } - private static void safeBinaryMMSparseDenseSkip(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMMSparseDenseSkip(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { SparseBlock a = m1.sparse ? m1.sparseBlock : m2.sparseBlock; if( a == null ) return; @@ -771,9 +744,7 @@ public class LibMatrixBincell } } - private static void safeBinaryMMGeneric(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryMMGeneric(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { int rlen = m1.rlen; int clen = m2.clen; for(int r=0; r<rlen; r++) @@ -796,9 +767,7 @@ public class LibMatrixBincell * @param bOp binary operator * */ - private static void performBinOuterOperation(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator bOp) - throws DMLRuntimeException - { + private static void performBinOuterOperation(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator bOp) { int rlen = m1.rlen; int clen = ret.clen; double b[] = DataConverter.convertToDoubleVector(m2); @@ -846,9 +815,7 @@ public class LibMatrixBincell ret.examSparsity(); } - private static void unsafeBinary(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) - throws DMLRuntimeException - { + private static void unsafeBinary(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op) { int rlen = m1.rlen; int clen = m1.clen; BinaryAccessType atype = getBinaryAccessType(m1, m2); @@ -924,9 +891,7 @@ public class LibMatrixBincell } } - private static void safeBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) - throws DMLRuntimeException - { + private static void safeBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) { //early abort possible since sparsesafe if( m1.isEmptyBlock(false) ) { return; @@ -994,11 +959,8 @@ public class LibMatrixBincell * @param m1 input matrix * @param ret result matrix * @param op scalar operator - * @throws DMLRuntimeException if DMLRuntimeException occurs */ - private static void unsafeBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) - throws DMLRuntimeException - { + private static void unsafeBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) { //early abort possible since sparsesafe if( m1.isEmptyBlock(false) ) { //compute 0 op constant once and set into dense output @@ -1053,9 +1015,7 @@ public class LibMatrixBincell } } - private static void denseBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) - throws DMLRuntimeException - { + private static void denseBinaryScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op) { //allocate dense block (if necessary), incl clear nnz ret.allocateDenseBlock(true); @@ -1076,9 +1036,7 @@ public class LibMatrixBincell ret.nonZeros = nnz; } - private static void safeBinaryInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) { //early abort on skip and empty if( m1ret.isEmptyBlock(false) && m2.isEmptyBlock(false) ) return; // skip entire empty block @@ -1096,9 +1054,7 @@ public class LibMatrixBincell safeBinaryInPlaceGeneric(m1ret, m2, op); } - private static void safeBinaryInPlaceSparse(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryInPlaceSparse(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) { if(m1ret.sparseBlock!=null) m1ret.allocateSparseRowsBlock(false); if(m2.sparseBlock!=null) @@ -1173,9 +1129,7 @@ public class LibMatrixBincell m1ret.recomputeNonZeros(); } - private static void safeBinaryInPlaceDense(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryInPlaceDense(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) { //prepare outputs m1ret.allocateDenseBlock(); DenseBlock a = m1ret.getDenseBlock(); @@ -1206,9 +1160,7 @@ public class LibMatrixBincell m1ret.setNonZeros(lnnz); } - private static void safeBinaryInPlaceGeneric(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) - throws DMLRuntimeException - { + private static void safeBinaryInPlaceGeneric(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) { final int rlen = m1ret.rlen; final int clen = m1ret.clen; @@ -1240,7 +1192,7 @@ public class LibMatrixBincell } } - private static void unsafeBinaryInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) throws DMLRuntimeException + private static void unsafeBinaryInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op) { int rlen = m1ret.rlen; int clen = m1ret.clen; @@ -1281,9 +1233,7 @@ public class LibMatrixBincell } private static void mergeForSparseBinary(BinaryOperator op, double[] values1, int[] cols1, int pos1, int size1, - double[] values2, int[] cols2, int pos2, int size2, int resultRow, MatrixBlock result) - throws DMLRuntimeException - { + double[] values2, int[] cols2, int pos2, int size2, int resultRow, MatrixBlock result) { int p1 = 0, p2 = 0; if( op.fn instanceof Multiply ) { //skip empty //skip empty: merge-join (with inner join semantics) @@ -1328,9 +1278,7 @@ public class LibMatrixBincell } private static void appendLeftForSparseBinary(BinaryOperator op, double[] values1, int[] cols1, int pos1, int size1, - int pos, int resultRow, MatrixBlock result) - throws DMLRuntimeException - { + int pos, int resultRow, MatrixBlock result) { for(int j=pos1+pos; j<pos1+size1; j++) { double v = op.fn.execute(values1[j], 0); result.appendValue(resultRow, cols1[j], v); @@ -1338,8 +1286,7 @@ public class LibMatrixBincell } private static void appendRightForSparseBinary(BinaryOperator op, double[] values2, int[] cols2, int pos2, int size2, - int pos, int resultRow, MatrixBlock result) throws DMLRuntimeException - { + int pos, int resultRow, MatrixBlock result) { for( int j=pos2+pos; j<pos2+size2; j++ ) { double v = op.fn.execute(0, values2[j]); result.appendValue(resultRow, cols2[j], v);
