org.apache.sysds.runtime.matrix.data

## Class MatrixValue

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

- All Implemented Interfaces:
    Comparable, org.apache.hadoop.io.Writable, org.apache.hadoop.io.WritableComparable
  Direct Known Subclasses:
    CM_N_COVCell, MatrixBlock, MatrixCell

      public abstract class MatrixValue
      extends Object
      implements org.apache.hadoop.io.WritableComparable

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `MatrixValue.CellIndex`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MatrixValue()`
    `MatrixValue(MatrixValue that)`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract MatrixValue` | `aggregateUnaryOperations(AggregateUnaryOperator op, MatrixValue result, int blen, MatrixIndexes indexesIn)`
    `abstract MatrixValue` | `aggregateUnaryOperations(AggregateUnaryOperator op, MatrixValue result, int blen, MatrixIndexes indexesIn, boolean inCP)`
    `abstract void` | `append(MatrixValue valueIn2, ArrayList<IndexedMatrixValue> outlist, int blen, boolean cbind, boolean m2IsLast, int nextNCol)`
    `abstract MatrixValue` | `binaryOperations(BinaryOperator op, MatrixValue thatValue, MatrixValue result)`
    `abstract MatrixValue` | `binaryOperationsInPlace(BinaryOperator op, MatrixValue thatValue)`
    `abstract void` | `copy(MatrixValue that)` Copy that MatrixValue into this MatrixValue.
    `abstract void` | `copy(MatrixValue that, boolean sp)` Copy that MatrixValue into this MatrixValue.
    `abstract void` | `ctableOperations(Operator op, double scalar_that, double scalar_that2, CTableMap resultMap, MatrixBlock resultBlock)`
    `abstract void` | `ctableOperations(Operator op, double scalarThat, MatrixValue that2, CTableMap ctableResult, MatrixBlock ctableResultBlock)`
    `abstract void` | `ctableOperations(Operator op, MatrixIndexes ix1, double scalar_that, boolean left, int blen, CTableMap resultMap, MatrixBlock resultBlock)`
    `abstract void` | `ctableOperations(Operator op, MatrixValue that, double scalar_that2, boolean ignoreZeros, CTableMap resultMap, MatrixBlock resultBlock)`
    `abstract void` | `ctableOperations(Operator op, MatrixValue that, MatrixValue that2, CTableMap resultMap, MatrixBlock resultBlock)`
    `abstract long` | `getNonZeros()`
    `abstract int` | `getNumColumns()`
    `abstract int` | `getNumRows()`
    `abstract double` | `getValue(int r, int c)`
    `abstract void` | `incrementalAggregate(AggregateOperator aggOp, MatrixValue newWithCorrection)`
    `abstract void` | `incrementalAggregate(AggregateOperator aggOp, MatrixValue correction, MatrixValue newWithCorrection, boolean deep)`
    `abstract boolean` | `isEmpty()`
    `abstract boolean` | `isInSparseFormat()`
    `abstract MatrixValue` | `reorgOperations(ReorgOperator op, MatrixValue result, int startRow, int startColumn, int length)`
    `abstract MatrixValue` | `replaceOperations(MatrixValue result, double pattern, double replacement)`
    `abstract void` | `reset()`
    `abstract void` | `reset(int rl, int cl)`
    `abstract void` | `reset(int rl, int cl, boolean sp)`
    `abstract void` | `reset(int rl, int cl, boolean sp, long nnzs)`
    `abstract void` | `reset(int rl, int cl, double v)`
    `abstract MatrixValue` | `scalarOperations(ScalarOperator op, MatrixValue result)`
    `abstract void` | `setValue(int r, int c, double v)`
    `abstract void` | `slice(ArrayList<IndexedMatrixValue> outlist, IndexRange range, int rowCut, int colCut, int blen, int boundaryRlen, int boundaryClen)` Slice out up to 4 matrixBlocks that are separated by the row and col Cuts.
    `abstract MatrixValue` | `unaryOperations(UnaryOperator op, MatrixValue result)`
    `abstract MatrixValue` | `zeroOutOperations(MatrixValue result, IndexRange range, boolean complementary)`

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

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.apache.hadoop.io.Writable

      `readFields, write`

    - ### Methods inherited from interface java.lang.Comparable

      `compareTo`

- - ### Constructor Detail

    - #### MatrixValue

          public MatrixValue()

    - #### MatrixValue

          public MatrixValue(MatrixValue that)

  - ### Method Detail

    - #### getNumRows

          public abstract int getNumRows()

    - #### getNumColumns

          public abstract int getNumColumns()

    - #### getNonZeros

          public abstract long getNonZeros()

    - #### setValue

          public abstract void setValue(int r,
                                        int c,
                                        double v)

    - #### getValue

          public abstract double getValue(int r,
                                          int c)

    - #### isInSparseFormat

          public abstract boolean isInSparseFormat()

    - #### isEmpty

          public abstract boolean isEmpty()

    - #### reset

          public abstract void reset()

    - #### reset

          public abstract void reset(int rl,
                                     int cl)

    - #### reset

          public abstract void reset(int rl,
                                     int cl,
                                     boolean sp)

    - #### reset

          public abstract void reset(int rl,
                                     int cl,
                                     boolean sp,
                                     long nnzs)

    - #### reset

          public abstract void reset(int rl,
                                     int cl,
                                     double v)

    - #### copy

          public abstract void copy(MatrixValue that)

      Copy that MatrixValue into this MatrixValue. If the MatrixValue is a MatrixBlock evaluate the sparsity of the original matrix, and copy into either a sparse or a dense matrix.
      Parameters:
        `that` - object to copy the values into.

    - #### copy

          public abstract void copy(MatrixValue that,
                                    boolean sp)

      Copy that MatrixValue into this MatrixValue. But select sparse destination block depending on boolean parameter.
      Parameters:
        `that` - object to copy the values into.
        `sp` - boolean specifying if output should be forced sparse or dense. (only applicable if the 'that' is a MatrixBlock)

    - #### scalarOperations

          public abstract MatrixValue scalarOperations(ScalarOperator op,
                                                       MatrixValue result)

    - #### binaryOperations

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

    - #### binaryOperationsInPlace

          public abstract MatrixValue binaryOperationsInPlace(BinaryOperator op,
                                                              MatrixValue thatValue)

    - #### reorgOperations

          public abstract MatrixValue reorgOperations(ReorgOperator op,
                                                      MatrixValue result,
                                                      int startRow,
                                                      int startColumn,
                                                      int length)

    - #### ctableOperations

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

    - #### ctableOperations

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

    - #### ctableOperations

          public abstract void ctableOperations(Operator op,
                                                double scalar_that,
                                                double scalar_that2,
                                                CTableMap resultMap,
                                                MatrixBlock resultBlock)

    - #### ctableOperations

          public abstract void ctableOperations(Operator op,
                                                MatrixIndexes ix1,
                                                double scalar_that,
                                                boolean left,
                                                int blen,
                                                CTableMap resultMap,
                                                MatrixBlock resultBlock)

    - #### ctableOperations

          public abstract void ctableOperations(Operator op,
                                                double scalarThat,
                                                MatrixValue that2,
                                                CTableMap ctableResult,
                                                MatrixBlock ctableResultBlock)

    - #### aggregateUnaryOperations

          public abstract MatrixValue aggregateUnaryOperations(AggregateUnaryOperator op,
                                                               MatrixValue result,
                                                               int blen,
                                                               MatrixIndexes indexesIn)

    - #### aggregateUnaryOperations

          public abstract MatrixValue aggregateUnaryOperations(AggregateUnaryOperator op,
                                                               MatrixValue result,
                                                               int blen,
                                                               MatrixIndexes indexesIn,
                                                               boolean inCP)

    - #### unaryOperations

          public abstract MatrixValue unaryOperations(UnaryOperator op,
                                                      MatrixValue result)

    - #### incrementalAggregate

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

    - #### incrementalAggregate

          public abstract void incrementalAggregate(AggregateOperator aggOp,
                                                    MatrixValue newWithCorrection)

    - #### zeroOutOperations

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

    - #### slice

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

      Slice out up to 4 matrixBlocks that are separated by the row and col Cuts. This is used in the context of spark execution to distributed sliced out matrix blocks of correct block size.
      Parameters:
        `outlist` - The output matrix blocks that is extracted from the matrix
        `range` - An index range containing overlapping information.
        `rowCut` - The row to cut and split the matrix.
        `colCut` - The column to cut ans split the matrix.
        `blen` - The Block size of the output matrices.
        `boundaryRlen` - The row length of the edge case matrix block, used for the final blocks that does not have enough rows to construct a full block.
        `boundaryClen` - The col length of the edge case matrix block, used for the final blocks that does not have enough cols to construct a full block.

    - #### replaceOperations

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

    - #### append

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

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