org.apache.sysds.runtime.compress

## Class AbstractCompressedMatrixBlock

- java.lang.Object
- - org.apache.sysds.runtime.matrix.data.MatrixValue
  - - org.apache.sysds.runtime.matrix.data.MatrixBlock
    - - org.apache.sysds.runtime.compress.AbstractCompressedMatrixBlock

- All Implemented Interfaces:
    Externalizable, Serializable, Comparable, org.apache.hadoop.io.Writable, org.apache.hadoop.io.WritableComparable, CacheBlock
  Direct Known Subclasses:
    CompressedMatrixBlock

      public abstract class AbstractCompressedMatrixBlock
      extends MatrixBlock

  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.apache.sysds.runtime.matrix.data.MatrixBlock

      `MatrixBlock.SparsityEstimate`

    - ### Nested classes/interfaces inherited from class org.apache.sysds.runtime.matrix.data.MatrixValue

      `MatrixValue.CellIndex`

  - ### Field Summary

    - ### Fields inherited from class org.apache.sysds.runtime.matrix.data.MatrixBlock

      `CONVERT_MCSR_TO_CSR_ON_DEEP_SERIALIZE, DEFAULT_INPLACE_SPARSEBLOCK, DEFAULT_SPARSEBLOCK, HEADER_SIZE, MAX_SHALLOW_SERIALIZE_OVERHEAD, SPARSITY_TURN_POINT, ULTRA_SPARSE_BLOCK_NNZ, ULTRA_SPARSITY_TURN_POINT, ULTRA_SPARSITY_TURN_POINT2`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractCompressedMatrixBlock()` Constructor for building an empty Compressed Matrix block object.
    `AbstractCompressedMatrixBlock(int rl, int cl, boolean sparse)` Main constructor for building a block from scratch.
    `AbstractCompressedMatrixBlock(MatrixBlock that)` "Copy" constructor to populate this compressed block with the uncompressed contents of a conventional block.

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `MatrixBlock` | `aggregateBinaryOperations(MatrixIndexes m1Index, MatrixBlock m1Value, MatrixIndexes m2Index, MatrixBlock m2Value, MatrixBlock result, AggregateBinaryOperator op)`
    `MatrixBlock` | `aggregateTernaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, AggregateTernaryOperator op, boolean inCP)`
    `MatrixBlock` | `append(MatrixBlock that, MatrixBlock ret, boolean cbind)`
    `void` | `append(MatrixValue v2, ArrayList<IndexedMatrixValue> outlist, int blen, boolean cbind, boolean m2IsLast, int nextNCol)`
    `MatrixBlock` | `binaryOperations(BinaryOperator op, MatrixValue thatValue, MatrixValue result)`
    `MatrixBlock` | `binaryOperationsInPlace(BinaryOperator op, MatrixValue thatValue)`
    `CM_COV_Object` | `cmOperations(CMOperator op)`
    `CM_COV_Object` | `cmOperations(CMOperator op, MatrixBlock weights)`
    `CM_COV_Object` | `covOperations(COVOperator op, MatrixBlock that)`
    `CM_COV_Object` | `covOperations(COVOperator op, MatrixBlock that, MatrixBlock weights)`
    `void` | `ctableOperations(Operator op, double scalar, double scalar2, CTableMap resultMap, MatrixBlock resultBlock)` D = ctable(A,v2,w) this <- A; scalar_that <- v2; scalar_that2 <- w; result <- D (i1,j1,v1) from input1 (this) (v2) from sclar_input2 (scalarThat) (w) from scalar_input3 (scalarThat2)
    `void` | `ctableOperations(Operator op, double scalar, MatrixValue that, CTableMap resultMap, MatrixBlock resultBlock)` D = ctable(A,v2,W) this <- A; scalarThat <- v2; that2 <- W; result <- D (i1,j1,v1) from input1 (this) (v2) from sclar_input2 (scalarThat) (i3,j3,w) from input3 (that2)
    `void` | `ctableOperations(Operator op, MatrixIndexes ix1, double scalar, boolean left, int brlen, CTableMap resultMap, MatrixBlock resultBlock)` Specific ctable case of ctable(seq(...),X), where X is the only matrix input.
    `void` | `ctableOperations(Operator op, MatrixValue that, double scalar, boolean ignoreZeros, CTableMap resultMap, MatrixBlock resultBlock)` D = ctable(A,B,w) this <- A; that <- B; scalar_that2 <- w; result <- D (i1,j1,v1) from input1 (this) (i1,j1,v2) from input2 (that) (w) from scalar_input3 (scalarThat2) NOTE: This method supports both vectors and matrices.
    `void` | `ctableOperations(Operator op, MatrixValue that, MatrixValue that2, CTableMap resultMap)` D = ctable(A,B,W) this <- A; that <- B; that2 <- W; result <- D (i1,j1,v1) from input1 (this) (i1,j1,v2) from input2 (that) (i1,j1,w) from input3 (that2)
    `void` | `ctableOperations(Operator op, MatrixValue that, MatrixValue that2, CTableMap resultMap, MatrixBlock resultBlock)`
    `MatrixBlock` | `ctableSeqOperations(MatrixValue that, double scalar, MatrixBlock resultBlock)` D = ctable(seq,A,w) this <- seq; thatMatrix <- A; thatScalar <- w; result <- D (i1,j1,v1) from input1 (this) (i1,j1,v2) from input2 (that) (w) from scalar_input3 (scalarThat2)
    `abstract MatrixBlock` | `decompress()`
    `static long` | `estimateOriginalSizeInMemory(int nrows, int ncols, double sparsity)`
    `MatrixBlock` | `groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, Operator op)` Invocation from CP instructions.
    `MatrixBlock` | `groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, Operator op, int k)`
    `void` | `incrementalAggregate(AggregateOperator aggOp, MatrixValue newWithCorrection)`
    `void` | `incrementalAggregate(AggregateOperator aggOp, MatrixValue correction, MatrixValue newWithCorrection, boolean deep)`
    `boolean` | `isEmptyBlock(boolean safe)`
    `boolean` | `isShallowSerialize()` Indicates if the cache block is subject to shallow serialized, which is generally true if in-memory size and serialized size are almost identical allowing to avoid unnecessary deep serialize.
    `boolean` | `isShallowSerialize(boolean inclConvert)` Indicates if the cache block is subject to shallow serialized, which is generally true if in-memory size and serialized size are almost identical allowing to avoid unnecessary deep serialize.
    `MatrixBlock` | `leftIndexingOperations(MatrixBlock rhsMatrix, int rl, int ru, int cl, int cu, MatrixBlock ret, MatrixObject.UpdateType update)`
    `MatrixBlock` | `leftIndexingOperations(ScalarObject scalar, int rl, int cl, MatrixBlock ret, MatrixObject.UpdateType update)` Explicitly allow left indexing for scalars.
    `void` | `permutationMatrixMultOperations(MatrixValue m2Val, MatrixValue out1Val, MatrixValue out2Val)`
    `void` | `permutationMatrixMultOperations(MatrixValue m2Val, MatrixValue out1Val, MatrixValue out2Val, int k)`
    `MatrixBlock` | `quaternaryOperations(QuaternaryOperator qop, MatrixBlock um, MatrixBlock vm, MatrixBlock wm, MatrixBlock out)`
    `MatrixBlock` | `quaternaryOperations(QuaternaryOperator qop, MatrixBlock um, MatrixBlock vm, MatrixBlock wm, MatrixBlock out, int k)`
    `MatrixBlock` | `randOperationsInPlace(RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed)` Function to generate a matrix of random numbers.
    `MatrixBlock` | `randOperationsInPlace(RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed, int k)` Function to generate a matrix of random numbers.
    `MatrixBlock` | `removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn)`
    `MatrixBlock` | `removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
    `MatrixBlock` | `reorgOperations(ReorgOperator op, MatrixValue ret, int startRow, int startColumn, int length)`
    `MatrixBlock` | `replaceOperations(MatrixValue result, double pattern, double replacement)`
    `MatrixBlock` | `rexpandOperations(MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
    `MatrixBlock` | `seqOperationsInPlace(double from, double to, double incr)`
    `void` | `slice(ArrayList<IndexedMatrixValue> outlist, IndexRange range, int rowCut, int colCut, int blen, int boundaryRlen, int boundaryClen)`
    `MatrixBlock` | `slice(int rl, int ru, int cl, int cu, boolean deep, CacheBlock ret)` Method to perform rightIndex operation for a given lower and upper bounds in row and column dimensions.
    `MatrixBlock` | `sortOperations(MatrixValue weights, MatrixBlock result)`
    `MatrixBlock` | `ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret)`
    `void` | `toShallowSerializeBlock()` Converts a cache block that is not shallow serializable into a form that is shallow serializable.
    `MatrixBlock` | `uaggouterchainOperations(MatrixBlock mbLeft, MatrixBlock mbRight, MatrixBlock mbOut, BinaryOperator bOp, AggregateUnaryOperator uaggOp)`
    `MatrixBlock` | `unaryOperations(UnaryOperator op, MatrixValue result)`
    `MatrixBlock` | `zeroOutOperations(MatrixValue result, IndexRange range, boolean complementary)`

    - ### Methods inherited from class org.apache.sysds.runtime.matrix.data.MatrixBlock

      `aggregateBinaryOperations, aggregateUnaryOperations, aggregateUnaryOperations, allocateAndResetSparseBlock, allocateBlock, allocateBlockAsync, allocateDenseBlock, allocateDenseBlock, allocateDenseBlockUnsafe, allocateSparseRowsBlock, allocateSparseRowsBlock, append, append, appendRow, appendRow, appendRowToSparse, appendToSparse, appendToSparse, appendValue, chainMatrixMultOperations, chainMatrixMultOperations, checkNaN, checkNonZeros, checkSparseRows, checkSparseRows, cleanupBlock, compactEmptyBlock, compareTo, computeIQMCorrection, containsValue, copy, copy, copy, copyShallow, dropLastRowsOrColumns, equals, estimateSizeDenseInMemory, estimateSizeInMemory, estimateSizeInMemory, estimateSizeOnDisk, estimateSizeOnDisk, estimateSizeSparseInMemory, estimateSizeSparseInMemory, estimateSparsityOnAggBinary, evalSparseFormatInMemory, evalSparseFormatInMemory, evalSparseFormatInMemory, evalSparseFormatOnDisk, evalSparseFormatOnDisk, examSparsity, examSparsity, extractTriangular, getDataCharacteristics, getDenseBlock, getDenseBlockValues, getExactSerializedSize, getExactSizeOnDisk, getInMemorySize, getLength, getNonZeros, getNumColumns, getNumRows, getSparseBlock, getSparseBlockIterator, getSparseBlockIterator, getSparsity, getValue, getValueDenseUnsafe, hashCode, init, init, interQuartileMean, isAllocated, isEmpty, isEmptyBlock, isInSparseFormat, isSparsePermutationMatrix, isThreadSafe, isThreadSafe, isUltraSparse, isUltraSparse, isVector, leftIndexingOperations, max, mean, median, merge, merge, merge, merge, min, minNonZero, naryOperations, pickValue, pickValue, pickValues, prod, quickGetValue, quickSetValue, randOperations, randOperations, randOperations, randOperations, readExternal, readFields, recomputeNonZeros, recomputeNonZeros, recomputeNonZeros, reset, reset, reset, reset, reset, reset, sampleOperations, scalarOperations, seqOperations, setNonZeros, setNumColumns, setNumRows, setSparseBlock, setValue, slice, slice, slice, sortSparseRows, sortSparseRows, sparseToDense, sum, sumSq, sumWeightForQuantile, toString, transposeSelfMatrixMultOperations, transposeSelfMatrixMultOperations, write, writeExternal`

    - ### Methods inherited from class java.lang.Object

      `getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### AbstractCompressedMatrixBlock

          public AbstractCompressedMatrixBlock()

      Constructor for building an empty Compressed Matrix block object.

    - #### AbstractCompressedMatrixBlock

          public AbstractCompressedMatrixBlock(int rl,
                                               int cl,
                                               boolean sparse)

      Main constructor for building a block from scratch.
      Parameters:
        `rl` - number of rows in the block
        `cl` - number of columns
        `sparse` - true if the UNCOMPRESSED representation of the block should be sparse

    - #### AbstractCompressedMatrixBlock

          public AbstractCompressedMatrixBlock(MatrixBlock that)

      "Copy" constructor to populate this compressed block with the uncompressed contents of a conventional block. Does not compress the block. Only creates a shallow copy, and only does deep copy on compression.
      Parameters:
        `that` - matrix block

  - ### Method Detail

    - #### decompress

          public abstract MatrixBlock decompress()

    - #### isEmptyBlock

          public boolean isEmptyBlock(boolean safe)

      Overrides:
        `isEmptyBlock` in class `MatrixBlock`

    - #### estimateOriginalSizeInMemory

          public static long estimateOriginalSizeInMemory(int nrows,
                                                          int ncols,
                                                          double sparsity)

    - #### unaryOperations

          public MatrixBlock unaryOperations(UnaryOperator op,
                                             MatrixValue result)

      Overrides:
        `unaryOperations` in class `MatrixBlock`

    - #### binaryOperations

          public MatrixBlock binaryOperations(BinaryOperator op,
                                              MatrixValue thatValue,
                                              MatrixValue result)

      Overrides:
        `binaryOperations` in class `MatrixBlock`

    - #### binaryOperationsInPlace

          public MatrixBlock binaryOperationsInPlace(BinaryOperator op,
                                                     MatrixValue thatValue)

      Overrides:
        `binaryOperationsInPlace` in class `MatrixBlock`

    - #### incrementalAggregate

          public void incrementalAggregate(AggregateOperator aggOp,
                                           MatrixValue correction,
                                           MatrixValue newWithCorrection,
                                           boolean deep)

      Overrides:
        `incrementalAggregate` in class `MatrixBlock`

    - #### incrementalAggregate

          public void incrementalAggregate(AggregateOperator aggOp,
                                           MatrixValue newWithCorrection)

      Overrides:
        `incrementalAggregate` in class `MatrixBlock`

    - #### reorgOperations

          public MatrixBlock reorgOperations(ReorgOperator op,
                                             MatrixValue ret,
                                             int startRow,
                                             int startColumn,
                                             int length)

      Overrides:
        `reorgOperations` in class `MatrixBlock`

    - #### append

          public MatrixBlock append(MatrixBlock that,
                                    MatrixBlock ret,
                                    boolean cbind)

      Overrides:
        `append` in class `MatrixBlock`

    - #### append

          public void append(MatrixValue v2,
                             ArrayList<IndexedMatrixValue> outlist,
                             int blen,
                             boolean cbind,
                             boolean m2IsLast,
                             int nextNCol)

      Overrides:
        `append` in class `MatrixBlock`

    - #### permutationMatrixMultOperations

          public void permutationMatrixMultOperations(MatrixValue m2Val,
                                                      MatrixValue out1Val,
                                                      MatrixValue out2Val)

      Overrides:
        `permutationMatrixMultOperations` in class `MatrixBlock`

    - #### permutationMatrixMultOperations

          public void permutationMatrixMultOperations(MatrixValue m2Val,
                                                      MatrixValue out1Val,
                                                      MatrixValue out2Val,
                                                      int k)

      Overrides:
        `permutationMatrixMultOperations` in class `MatrixBlock`

    - #### leftIndexingOperations

          public MatrixBlock leftIndexingOperations(MatrixBlock rhsMatrix,
                                                    int rl,
                                                    int ru,
                                                    int cl,
                                                    int cu,
                                                    MatrixBlock ret,
                                                    MatrixObject.UpdateType update)

      Overrides:
        `leftIndexingOperations` in class `MatrixBlock`

    - #### leftIndexingOperations

          public MatrixBlock leftIndexingOperations(ScalarObject scalar,
                                                    int rl,
                                                    int cl,
                                                    MatrixBlock ret,
                                                    MatrixObject.UpdateType update)

      Description copied from class: `MatrixBlock`
      Explicitly allow left indexing for scalars. Note: This operation is now 0-based. * Operations to be performed: 1) result=this; 2) result[row,column] = scalar.getDoubleValue();
      Overrides:
        `leftIndexingOperations` in class `MatrixBlock`
      Parameters:
        `scalar` - scalar object
        `rl` - row lower
        `cl` - column lower
        `ret` - ?
        `update` - ?
      Returns:
        matrix block

    - #### slice

          public MatrixBlock slice(int rl,
                                   int ru,
                                   int cl,
                                   int cu,
                                   boolean deep,
                                   CacheBlock ret)

      Description copied from class: `MatrixBlock`
      Method to perform rightIndex operation for a given lower and upper bounds in row and column dimensions. Extracted submatrix is returned as "result". Note: This operation is now 0-based.
      Overrides:
        `slice` in class `MatrixBlock`
      Parameters:
        `rl` - row lower
        `ru` - row upper
        `cl` - column lower
        `cu` - column upper
        `deep` - should perform deep copy
        `ret` - output matrix block
      Returns:
        matrix block output matrix block

    - #### slice

          public void slice(ArrayList<IndexedMatrixValue> outlist,
                            IndexRange range,
                            int rowCut,
                            int colCut,
                            int blen,
                            int boundaryRlen,
                            int boundaryClen)

      Overrides:
        `slice` in class `MatrixBlock`

    - #### zeroOutOperations

          public MatrixBlock zeroOutOperations(MatrixValue result,
                                               IndexRange range,
                                               boolean complementary)

      Overrides:
        `zeroOutOperations` in class `MatrixBlock`

    - #### cmOperations

          public CM_COV_Object cmOperations(CMOperator op)

      Overrides:
        `cmOperations` in class `MatrixBlock`

    - #### cmOperations

          public CM_COV_Object cmOperations(CMOperator op,
                                            MatrixBlock weights)

      Overrides:
        `cmOperations` in class `MatrixBlock`

    - #### covOperations

          public CM_COV_Object covOperations(COVOperator op,
                                             MatrixBlock that)

      Overrides:
        `covOperations` in class `MatrixBlock`

    - #### covOperations

          public CM_COV_Object covOperations(COVOperator op,
                                             MatrixBlock that,
                                             MatrixBlock weights)

      Overrides:
        `covOperations` in class `MatrixBlock`

    - #### sortOperations

          public MatrixBlock sortOperations(MatrixValue weights,
                                            MatrixBlock result)

      Overrides:
        `sortOperations` in class `MatrixBlock`

    - #### aggregateBinaryOperations

          public MatrixBlock aggregateBinaryOperations(MatrixIndexes m1Index,
                                                       MatrixBlock m1Value,
                                                       MatrixIndexes m2Index,
                                                       MatrixBlock m2Value,
                                                       MatrixBlock result,
                                                       AggregateBinaryOperator op)

      Overrides:
        `aggregateBinaryOperations` in class `MatrixBlock`

    - #### aggregateTernaryOperations

          public MatrixBlock aggregateTernaryOperations(MatrixBlock m1,
                                                        MatrixBlock m2,
                                                        MatrixBlock m3,
                                                        MatrixBlock ret,
                                                        AggregateTernaryOperator op,
                                                        boolean inCP)

      Overrides:
        `aggregateTernaryOperations` in class `MatrixBlock`

    - #### uaggouterchainOperations

          public MatrixBlock uaggouterchainOperations(MatrixBlock mbLeft,
                                                      MatrixBlock mbRight,
                                                      MatrixBlock mbOut,
                                                      BinaryOperator bOp,
                                                      AggregateUnaryOperator uaggOp)

      Overrides:
        `uaggouterchainOperations` in class `MatrixBlock`

    - #### groupedAggOperations

          public MatrixBlock groupedAggOperations(MatrixValue tgt,
                                                  MatrixValue wghts,
                                                  MatrixValue ret,
                                                  int ngroups,
                                                  Operator op)

      Description copied from class: `MatrixBlock`
      Invocation from CP instructions. The aggregate is computed on the groups object against target and weights. Notes: * The computed number of groups is reused for multiple invocations with different target. * This implementation supports that the target is passed as column or row vector, in case of row vectors we also use sparse-safe implementations for sparse safe aggregation operators.
      Overrides:
        `groupedAggOperations` in class `MatrixBlock`
      Parameters:
        `tgt` - ?
        `wghts` - ?
        `ret` - ?
        `ngroups` - ?
        `op` - operator
      Returns:
        matrix block

    - #### groupedAggOperations

          public MatrixBlock groupedAggOperations(MatrixValue tgt,
                                                  MatrixValue wghts,
                                                  MatrixValue ret,
                                                  int ngroups,
                                                  Operator op,
                                                  int k)

      Overrides:
        `groupedAggOperations` in class `MatrixBlock`

    - #### removeEmptyOperations

          public MatrixBlock removeEmptyOperations(MatrixBlock ret,
                                                   boolean rows,
                                                   boolean emptyReturn,
                                                   MatrixBlock select)

      Overrides:
        `removeEmptyOperations` in class `MatrixBlock`

    - #### removeEmptyOperations

          public MatrixBlock removeEmptyOperations(MatrixBlock ret,
                                                   boolean rows,
                                                   boolean emptyReturn)

      Overrides:
        `removeEmptyOperations` in class `MatrixBlock`

    - #### rexpandOperations

          public MatrixBlock rexpandOperations(MatrixBlock ret,
                                               double max,
                                               boolean rows,
                                               boolean cast,
                                               boolean ignore,
                                               int k)

      Overrides:
        `rexpandOperations` in class `MatrixBlock`

    - #### replaceOperations

          public MatrixBlock replaceOperations(MatrixValue result,
                                               double pattern,
                                               double replacement)

      Overrides:
        `replaceOperations` in class `MatrixBlock`

    - #### ctableOperations

          public void ctableOperations(Operator op,
                                       double scalar,
                                       MatrixValue that,
                                       CTableMap resultMap,
                                       MatrixBlock resultBlock)

      Description copied from class: `MatrixBlock`
      D = ctable(A,v2,W) this <- A; scalarThat <- v2; that2 <- W; result <- D (i1,j1,v1) from input1 (this) (v2) from sclar_input2 (scalarThat) (i3,j3,w) from input3 (that2)
      Overrides:
        `ctableOperations` in class `MatrixBlock`

    - #### ctableOperations

          public void ctableOperations(Operator op,
                                       double scalar,
                                       double scalar2,
                                       CTableMap resultMap,
                                       MatrixBlock resultBlock)

      Description copied from class: `MatrixBlock`
      D = ctable(A,v2,w) this <- A; scalar_that <- v2; scalar_that2 <- w; result <- D (i1,j1,v1) from input1 (this) (v2) from sclar_input2 (scalarThat) (w) from scalar_input3 (scalarThat2)
      Overrides:
        `ctableOperations` in class `MatrixBlock`

    - #### ctableOperations

          public void ctableOperations(Operator op,
                                       MatrixIndexes ix1,
                                       double scalar,
                                       boolean left,
                                       int brlen,
                                       CTableMap resultMap,
                                       MatrixBlock resultBlock)

      Description copied from class: `MatrixBlock`
      Specific ctable case of ctable(seq(...),X), where X is the only matrix input. The 'left' input parameter specifies if the seq appeared on the left, otherwise it appeared on the right.
      Overrides:
        `ctableOperations` in class `MatrixBlock`

    - #### ctableOperations

          public void ctableOperations(Operator op,
                                       MatrixValue that,
                                       double scalar,
                                       boolean ignoreZeros,
                                       CTableMap resultMap,
                                       MatrixBlock resultBlock)

      Description copied from class: `MatrixBlock`
      D = ctable(A,B,w) this <- A; that <- B; scalar_that2 <- w; result <- D (i1,j1,v1) from input1 (this) (i1,j1,v2) from input2 (that) (w) from scalar_input3 (scalarThat2) NOTE: This method supports both vectors and matrices. In case of matrices and ignoreZeros=true we can also use a sparse-safe implementation
      Overrides:
        `ctableOperations` in class `MatrixBlock`

    - #### ctableSeqOperations

          public MatrixBlock ctableSeqOperations(MatrixValue that,
                                                 double scalar,
                                                 MatrixBlock resultBlock)

      Description copied from class: `MatrixBlock`
      D = ctable(seq,A,w) this <- seq; thatMatrix <- A; thatScalar <- w; result <- D (i1,j1,v1) from input1 (this) (i1,j1,v2) from input2 (that) (w) from scalar_input3 (scalarThat2)
      Overrides:
        `ctableSeqOperations` in class `MatrixBlock`
      Parameters:
        `that` - matrix value
        `scalar` - scalar double
        `resultBlock` - result matrix block
      Returns:
        resultBlock

    - #### ctableOperations

          public void ctableOperations(Operator op,
                                       MatrixValue that,
                                       MatrixValue that2,
                                       CTableMap resultMap)

      Description copied from class: `MatrixBlock`
      D = ctable(A,B,W) this <- A; that <- B; that2 <- W; result <- D (i1,j1,v1) from input1 (this) (i1,j1,v2) from input2 (that) (i1,j1,w) from input3 (that2)
      Overrides:
        `ctableOperations` in class `MatrixBlock`
      Parameters:
        `op` - operator
        `that` - matrix value 1
        `that2` - matrix value 2
        `resultMap` - table map

    - #### ctableOperations

          public void ctableOperations(Operator op,
                                       MatrixValue that,
                                       MatrixValue that2,
                                       CTableMap resultMap,
                                       MatrixBlock resultBlock)

      Overrides:
        `ctableOperations` in class `MatrixBlock`

    - #### ternaryOperations

          public MatrixBlock ternaryOperations(TernaryOperator op,
                                               MatrixBlock m2,
                                               MatrixBlock m3,
                                               MatrixBlock ret)

      Overrides:
        `ternaryOperations` in class `MatrixBlock`

    - #### quaternaryOperations

          public MatrixBlock quaternaryOperations(QuaternaryOperator qop,
                                                  MatrixBlock um,
                                                  MatrixBlock vm,
                                                  MatrixBlock wm,
                                                  MatrixBlock out)

      Overrides:
        `quaternaryOperations` in class `MatrixBlock`

    - #### quaternaryOperations

          public MatrixBlock quaternaryOperations(QuaternaryOperator qop,
                                                  MatrixBlock um,
                                                  MatrixBlock vm,
                                                  MatrixBlock wm,
                                                  MatrixBlock out,
                                                  int k)

      Overrides:
        `quaternaryOperations` in class `MatrixBlock`

    - #### randOperationsInPlace

          public MatrixBlock randOperationsInPlace(RandomMatrixGenerator rgen,
                                                   org.apache.commons.math3.random.Well1024a bigrand,
                                                   long bSeed)

      Description copied from class: `MatrixBlock`
      Function to generate a matrix of random numbers. This is invoked both from CP as well as from MR. In case of CP, it generates an entire matrix block-by-block. A `bigrand` is passed so that block-level seeds are generated internally. In case of MR, it generates a single block for given block-level seed `bSeed`. When pdf="uniform", cell values are drawn from uniform distribution in range `[min,max]`. When pdf="normal", cell values are drawn from standard normal distribution N(0,1). The range of generated values will always be (-Inf,+Inf).
      Overrides:
        `randOperationsInPlace` in class `MatrixBlock`
      Parameters:
        `rgen` - random matrix generator
        `bigrand` - ?
        `bSeed` - seed value
      Returns:
        matrix block

    - #### randOperationsInPlace

          public MatrixBlock randOperationsInPlace(RandomMatrixGenerator rgen,
                                                   org.apache.commons.math3.random.Well1024a bigrand,
                                                   long bSeed,
                                                   int k)

      Description copied from class: `MatrixBlock`
      Function to generate a matrix of random numbers. This is invoked both from CP as well as from MR. In case of CP, it generates an entire matrix block-by-block. A `bigrand` is passed so that block-level seeds are generated internally. In case of MR, it generates a single block for given block-level seed `bSeed`. When pdf="uniform", cell values are drawn from uniform distribution in range `[min,max]`. When pdf="normal", cell values are drawn from standard normal distribution N(0,1). The range of generated values will always be (-Inf,+Inf).
      Overrides:
        `randOperationsInPlace` in class `MatrixBlock`
      Parameters:
        `rgen` - random matrix generator
        `bigrand` - ?
        `bSeed` - seed value
        `k` - ?
      Returns:
        matrix block

    - #### seqOperationsInPlace

          public MatrixBlock seqOperationsInPlace(double from,
                                                  double to,
                                                  double incr)

      Overrides:
        `seqOperationsInPlace` in class `MatrixBlock`

    - #### isShallowSerialize

          public boolean isShallowSerialize()

      Description copied from interface: `CacheBlock`
      Indicates if the cache block is subject to shallow serialized, which is generally true if in-memory size and serialized size are almost identical allowing to avoid unnecessary deep serialize.
      Specified by:
        `isShallowSerialize` in interface `CacheBlock`
      Overrides:
        `isShallowSerialize` in class `MatrixBlock`
      Returns:
        true if shallow serialized

    - #### isShallowSerialize

          public boolean isShallowSerialize(boolean inclConvert)

      Description copied from interface: `CacheBlock`
      Indicates if the cache block is subject to shallow serialized, which is generally true if in-memory size and serialized size are almost identical allowing to avoid unnecessary deep serialize.
      Specified by:
        `isShallowSerialize` in interface `CacheBlock`
      Overrides:
        `isShallowSerialize` in class `MatrixBlock`
      Parameters:
        `inclConvert` - if true report blocks as shallow serialize that are currently not amenable but can be brought into an amenable form via `toShallowSerializeBlock`.
      Returns:
        true if shallow serialized

    - #### toShallowSerializeBlock

          public void toShallowSerializeBlock()

      Description copied from interface: `CacheBlock`
      Converts a cache block that is not shallow serializable into a form that is shallow serializable. This methods has no affect if the given cache block is not amenable.
      Specified by:
        `toShallowSerializeBlock` in interface `CacheBlock`
      Overrides:
        `toShallowSerializeBlock` in class `MatrixBlock`

Copyright © 2020 The Apache Software Foundation. All rights reserved.