// Reused by both MR and Spark for performing zero out public static IndexRange getSelectedRangeForZeroOut( Pair<Long, FrameBlock> in, int blockRowFactor, int blockColFactor, IndexRange indexRange, long lSrcRowIndex, long lDestRowIndex) { int iRowStart, iRowEnd, iColStart, iColEnd; if (indexRange.rowStart <= lDestRowIndex) iRowStart = 0; else iRowStart = (int) (indexRange.rowStart - in.getKey()); iRowEnd = (int) Math.min(indexRange.rowEnd - lSrcRowIndex, blockRowFactor) - 1; iColStart = UtilFunctions.computeCellInBlock(indexRange.colStart, blockColFactor); iColEnd = UtilFunctions.computeCellInBlock(indexRange.colEnd, blockColFactor); return new IndexRange(iRowStart, iRowEnd, iColStart, iColEnd); }
// Reused by both MR and Spark for performing zero out public static IndexRange getSelectedRangeForZeroOut( IndexedMatrixValue in, int blockRowFactor, int blockColFactor, IndexRange indexRange) { IndexRange tempRange = new IndexRange(-1, -1, -1, -1); long topBlockRowIndex = UtilFunctions.computeBlockIndex(indexRange.rowStart, blockRowFactor); int topRowInTopBlock = UtilFunctions.computeCellInBlock(indexRange.rowStart, blockRowFactor); long bottomBlockRowIndex = UtilFunctions.computeBlockIndex(indexRange.rowEnd, blockRowFactor); int bottomRowInBottomBlock = UtilFunctions.computeCellInBlock(indexRange.rowEnd, blockRowFactor); long leftBlockColIndex = UtilFunctions.computeBlockIndex(indexRange.colStart, blockColFactor); int leftColInLeftBlock = UtilFunctions.computeCellInBlock(indexRange.colStart, blockColFactor); long rightBlockColIndex = UtilFunctions.computeBlockIndex(indexRange.colEnd, blockColFactor); int rightColInRightBlock = UtilFunctions.computeCellInBlock(indexRange.colEnd, blockColFactor); // no overlap if (in.getIndexes().getRowIndex() < topBlockRowIndex || in.getIndexes().getRowIndex() > bottomBlockRowIndex || in.getIndexes().getColumnIndex() < leftBlockColIndex || in.getIndexes().getColumnIndex() > rightBlockColIndex) { tempRange.set(-1, -1, -1, -1); return tempRange; } // get the index range inside the block tempRange.set(0, in.getValue().getNumRows() - 1, 0, in.getValue().getNumColumns() - 1); if (topBlockRowIndex == in.getIndexes().getRowIndex()) tempRange.rowStart = topRowInTopBlock; if (bottomBlockRowIndex == in.getIndexes().getRowIndex()) tempRange.rowEnd = bottomRowInBottomBlock; if (leftBlockColIndex == in.getIndexes().getColumnIndex()) tempRange.colStart = leftColInLeftBlock; if (rightBlockColIndex == in.getIndexes().getColumnIndex()) tempRange.colEnd = rightColInRightBlock; return tempRange; }
/** * @param in * @param ixrange * @param brlen * @param bclen * @param rlen * @param clen * @param outlist * @throws DMLRuntimeException */ public static void performShift( Pair<Long, FrameBlock> in, IndexRange ixrange, int brlenLeft, int clenLeft /*, int bclen*/, long rlen, long clen, ArrayList<Pair<Long, FrameBlock>> outlist) throws DMLRuntimeException { Long ix = in.getKey(); FrameBlock fb = in.getValue(); long start_lhs_globalRowIndex = ixrange.rowStart + (ix - 1); long start_lhs_globalColIndex = ixrange.colStart; long end_lhs_globalRowIndex = start_lhs_globalRowIndex + fb.getNumRows() - 1; long end_lhs_globalColIndex = ixrange.colEnd; long start_lhs_rowIndex = UtilFunctions.computeBlockIndex(start_lhs_globalRowIndex, brlenLeft); long end_lhs_rowIndex = UtilFunctions.computeBlockIndex(end_lhs_globalRowIndex, brlenLeft); for (long leftRowIndex = start_lhs_rowIndex; leftRowIndex <= end_lhs_rowIndex; leftRowIndex++) { // Calculate global index of right hand side block long lhs_rl = Math.max((leftRowIndex - 1) * brlenLeft + 1, start_lhs_globalRowIndex); long lhs_ru = Math.min(leftRowIndex * brlenLeft, end_lhs_globalRowIndex); long lhs_cl = start_lhs_globalColIndex; long lhs_cu = end_lhs_globalColIndex; int lhs_lrl = UtilFunctions.computeCellInBlock(lhs_rl, brlenLeft); int lhs_lru = UtilFunctions.computeCellInBlock(lhs_ru, brlenLeft); int lhs_lcl = (int) lhs_cl - 1; int lhs_lcu = (int) lhs_cu - 1; long rhs_rl = lhs_rl - (ixrange.rowStart - 1) - (ix - 1); long rhs_ru = rhs_rl + (lhs_ru - lhs_rl); long rhs_cl = lhs_cl - ixrange.colStart + 1; long rhs_cu = rhs_cl + (lhs_cu - lhs_cl); // local indices are 0 (zero) based. int rhs_lrl = (int) (UtilFunctions.computeCellInBlock(rhs_rl, fb.getNumRows())); int rhs_lru = (int) (UtilFunctions.computeCellInBlock(rhs_ru, fb.getNumRows())); int rhs_lcl = (int) rhs_cl - 1; int rhs_lcu = (int) rhs_cu - 1; FrameBlock slicedRHSBlk = fb.sliceOperations(rhs_lrl, rhs_lru, rhs_lcl, rhs_lcu, new FrameBlock()); int lbclen = clenLeft; List<ValueType> schemaPartialLeft = Collections.nCopies(lhs_lcl, ValueType.STRING); List<ValueType> schemaRHS = UtilFunctions.getSubSchema(fb.getSchema(), rhs_lcl, rhs_lcl - lhs_lcl + lhs_lcu); List<ValueType> schema = new ArrayList<ValueType>(schemaPartialLeft); schema.addAll(schemaRHS); List<ValueType> schemaPartialRight = Collections.nCopies(lbclen - schema.size(), ValueType.STRING); schema.addAll(schemaPartialRight); FrameBlock resultBlock = new FrameBlock(schema); int iRHSRows = (int) (leftRowIndex <= rlen / brlenLeft ? brlenLeft : rlen - (rlen / brlenLeft) * brlenLeft); resultBlock.ensureAllocatedColumns(iRHSRows); resultBlock = resultBlock.leftIndexingOperations( slicedRHSBlk, lhs_lrl, lhs_lru, lhs_lcl, lhs_lcu, new FrameBlock()); outlist.add(new Pair<Long, FrameBlock>((leftRowIndex - 1) * brlenLeft + 1, resultBlock)); } }
/** * @param in * @param ixrange * @param brlen * @param bclen * @param rlen * @param clen * @param outlist * @throws DMLRuntimeException */ public static void performShift( IndexedMatrixValue in, IndexRange ixrange, int brlen, int bclen, long rlen, long clen, ArrayList<IndexedMatrixValue> outlist) throws DMLRuntimeException { MatrixIndexes ix = in.getIndexes(); MatrixBlock mb = (MatrixBlock) in.getValue(); long start_lhs_globalRowIndex = ixrange.rowStart + (ix.getRowIndex() - 1) * brlen; long start_lhs_globalColIndex = ixrange.colStart + (ix.getColumnIndex() - 1) * bclen; long end_lhs_globalRowIndex = start_lhs_globalRowIndex + mb.getNumRows() - 1; long end_lhs_globalColIndex = start_lhs_globalColIndex + mb.getNumColumns() - 1; long start_lhs_rowIndex = UtilFunctions.computeBlockIndex(start_lhs_globalRowIndex, brlen); long end_lhs_rowIndex = UtilFunctions.computeBlockIndex(end_lhs_globalRowIndex, brlen); long start_lhs_colIndex = UtilFunctions.computeBlockIndex(start_lhs_globalColIndex, bclen); long end_lhs_colIndex = UtilFunctions.computeBlockIndex(end_lhs_globalColIndex, bclen); for (long leftRowIndex = start_lhs_rowIndex; leftRowIndex <= end_lhs_rowIndex; leftRowIndex++) { for (long leftColIndex = start_lhs_colIndex; leftColIndex <= end_lhs_colIndex; leftColIndex++) { // Calculate global index of right hand side block long lhs_rl = Math.max((leftRowIndex - 1) * brlen + 1, start_lhs_globalRowIndex); long lhs_ru = Math.min(leftRowIndex * brlen, end_lhs_globalRowIndex); long lhs_cl = Math.max((leftColIndex - 1) * bclen + 1, start_lhs_globalColIndex); long lhs_cu = Math.min(leftColIndex * bclen, end_lhs_globalColIndex); int lhs_lrl = UtilFunctions.computeCellInBlock(lhs_rl, brlen); int lhs_lru = UtilFunctions.computeCellInBlock(lhs_ru, brlen); int lhs_lcl = UtilFunctions.computeCellInBlock(lhs_cl, bclen); int lhs_lcu = UtilFunctions.computeCellInBlock(lhs_cu, bclen); long rhs_rl = lhs_rl - ixrange.rowStart + 1; long rhs_ru = rhs_rl + (lhs_ru - lhs_rl); long rhs_cl = lhs_cl - ixrange.colStart + 1; long rhs_cu = rhs_cl + (lhs_cu - lhs_cl); int rhs_lrl = UtilFunctions.computeCellInBlock(rhs_rl, brlen); int rhs_lru = UtilFunctions.computeCellInBlock(rhs_ru, brlen); int rhs_lcl = UtilFunctions.computeCellInBlock(rhs_cl, bclen); int rhs_lcu = UtilFunctions.computeCellInBlock(rhs_cu, bclen); MatrixBlock slicedRHSBlk = mb.sliceOperations(rhs_lrl, rhs_lru, rhs_lcl, rhs_lcu, new MatrixBlock()); int lbrlen = UtilFunctions.computeBlockSize(rlen, leftRowIndex, brlen); int lbclen = UtilFunctions.computeBlockSize(clen, leftColIndex, bclen); MatrixBlock resultBlock = new MatrixBlock(lbrlen, lbclen, false); resultBlock = resultBlock.leftIndexingOperations( slicedRHSBlk, lhs_lrl, lhs_lru, lhs_lcl, lhs_lcu, null, UpdateType.COPY); outlist.add( new IndexedMatrixValue(new MatrixIndexes(leftRowIndex, leftColIndex), resultBlock)); } } }
/** * @param val * @param range * @param brlen * @param bclen * @param outlist * @throws DMLRuntimeException */ public static void performSlice( IndexedMatrixValue in, IndexRange ixrange, int brlen, int bclen, ArrayList<IndexedMatrixValue> outlist) throws DMLRuntimeException { long cellIndexTopRow = UtilFunctions.computeCellIndex(in.getIndexes().getRowIndex(), brlen, 0); long cellIndexBottomRow = UtilFunctions.computeCellIndex( in.getIndexes().getRowIndex(), brlen, in.getValue().getNumRows() - 1); long cellIndexLeftCol = UtilFunctions.computeCellIndex(in.getIndexes().getColumnIndex(), bclen, 0); long cellIndexRightCol = UtilFunctions.computeCellIndex( in.getIndexes().getColumnIndex(), bclen, in.getValue().getNumColumns() - 1); long cellIndexOverlapTop = Math.max(cellIndexTopRow, ixrange.rowStart); long cellIndexOverlapBottom = Math.min(cellIndexBottomRow, ixrange.rowEnd); long cellIndexOverlapLeft = Math.max(cellIndexLeftCol, ixrange.colStart); long cellIndexOverlapRight = Math.min(cellIndexRightCol, ixrange.colEnd); // check if block is outside the indexing range if (cellIndexOverlapTop > cellIndexOverlapBottom || cellIndexOverlapLeft > cellIndexOverlapRight) { return; } IndexRange tmpRange = new IndexRange( UtilFunctions.computeCellInBlock(cellIndexOverlapTop, brlen), UtilFunctions.computeCellInBlock(cellIndexOverlapBottom, brlen), UtilFunctions.computeCellInBlock(cellIndexOverlapLeft, bclen), UtilFunctions.computeCellInBlock(cellIndexOverlapRight, bclen)); int rowCut = UtilFunctions.computeCellInBlock(ixrange.rowStart, brlen); int colCut = UtilFunctions.computeCellInBlock(ixrange.colStart, bclen); int rowsInLastBlock = (int) ((ixrange.rowEnd - ixrange.rowStart + 1) % brlen); if (rowsInLastBlock == 0) rowsInLastBlock = brlen; int colsInLastBlock = (int) ((ixrange.colEnd - ixrange.colStart + 1) % bclen); if (colsInLastBlock == 0) colsInLastBlock = bclen; long resultBlockIndexTop = UtilFunctions.computeBlockIndex(cellIndexOverlapTop - ixrange.rowStart + 1, brlen); long resultBlockIndexBottom = UtilFunctions.computeBlockIndex(cellIndexOverlapBottom - ixrange.rowStart + 1, brlen); long resultBlockIndexLeft = UtilFunctions.computeBlockIndex(cellIndexOverlapLeft - ixrange.colStart + 1, bclen); long resultBlockIndexRight = UtilFunctions.computeBlockIndex(cellIndexOverlapRight - ixrange.colStart + 1, bclen); int boundaryRlen = brlen; int boundaryClen = bclen; long finalBlockIndexBottom = UtilFunctions.computeBlockIndex(ixrange.rowEnd - ixrange.rowStart + 1, brlen); long finalBlockIndexRight = UtilFunctions.computeBlockIndex(ixrange.colEnd - ixrange.colStart + 1, bclen); if (resultBlockIndexBottom == finalBlockIndexBottom) boundaryRlen = rowsInLastBlock; if (resultBlockIndexRight == finalBlockIndexRight) boundaryClen = colsInLastBlock; // allocate space for the output value for (long r = resultBlockIndexTop; r <= resultBlockIndexBottom; r++) for (long c = resultBlockIndexLeft; c <= resultBlockIndexRight; c++) { IndexedMatrixValue out = new IndexedMatrixValue(new MatrixIndexes(), new MatrixBlock()); out.getIndexes().setIndexes(r, c); outlist.add(out); } // execute actual slice operation in.getValue() .sliceOperations( outlist, tmpRange, rowCut, colCut, brlen, bclen, boundaryRlen, boundaryClen); }