Package 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:
  `MatrixBlock`, `MatrixCell`

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

### Nested Class Summary

Nested Classes
`static class` `MatrixValue.CellIndex`

### Constructor Summary

Constructors
`MatrixValue()`
`MatrixValue​(MatrixValue that)`

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`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 double` `get​(int r, int c)`
`abstract long` `getNonZeros()`
`abstract int` `getNumColumns()`
`abstract int` `getNumRows()`
`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` `set​(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)`

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

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

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

`compareTo`

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

`readFields, write`

### 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()

#### set

    public abstract void set​(int r,
                             int c,
                             double v)

#### get

    public abstract double get​(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 final 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)

#### 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)