MatrixBlock (SystemML 0.14.0 API)

java.lang.Object
- org.apache.sysml.runtime.matrix.data.MatrixValue
- - org.apache.sysml.runtime.matrix.data.MatrixBlock

All Implemented Interfaces:

Externalizable, Serializable, Comparable, org.apache.hadoop.io.Writable, org.apache.hadoop.io.WritableComparable, org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Direct Known Subclasses:

CompressedMatrixBlock
```
public class MatrixBlock
extends MatrixValue
implements org.apache.sysml.runtime.controlprogram.caching.CacheBlock, Externalizable
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class MatrixBlock.BlockType

static class MatrixBlock.SparsityEstimate
- Nested classes/interfaces inherited from class org.apache.sysml.runtime.matrix.data.MatrixValue
  MatrixValue.CellIndex

Nested Classes
Modifier and Type	Class and Description
`static class`	`MatrixBlock.BlockType`
`static class`	`MatrixBlock.SparsityEstimate`

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`clen`
`static SparseBlock.Type`	`DEFAULT_INPLACE_SPARSEBLOCK`
`static SparseBlock.Type`	`DEFAULT_SPARSEBLOCK`
`protected double[]`	`denseBlock`
`protected boolean`	`diag`
`protected int`	`estimatedNNzsPerRow`
`static int`	`HEADER_SIZE`
`protected long`	`nonZeros`
`protected int`	`numGroups`
`protected int`	`rlen`
`protected boolean`	`sparse`
`protected SparseBlock`	`sparseBlock`
`static double`	`SPARSITY_TURN_POINT`
`static double`	`ULTRA_SPARSITY_TURN_POINT`

Constructor Summary

Constructors
Constructor and Description
`MatrixBlock()`
`MatrixBlock(int rl, int cl, boolean sp)`
`MatrixBlock(int rl, int cl, boolean sp, long estnnz)`
`MatrixBlock(int rl, int cl, long estnnz)`
`MatrixBlock(int rl, int cl, long nnz, SparseBlock sblock)` Constructs a sparse `MatrixBlock` with a given instance of a `SparseBlock`
`MatrixBlock(MatrixBlock that)`
`MatrixBlock(MatrixBlock that, SparseBlock.Type stype, boolean deep)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`MatrixValue`	`aggregateBinaryOperations(MatrixIndexes m1Index, MatrixValue m1Value, MatrixIndexes m2Index, MatrixValue m2Value, MatrixValue result, org.apache.sysml.runtime.matrix.operators.AggregateBinaryOperator op)`
`MatrixValue`	`aggregateBinaryOperations(MatrixValue m1Value, MatrixValue m2Value, MatrixValue result, org.apache.sysml.runtime.matrix.operators.AggregateBinaryOperator op)`
`MatrixBlock`	`aggregateTernaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, org.apache.sysml.runtime.matrix.operators.AggregateTernaryOperator op, boolean inCP)`
`MatrixValue`	`aggregateUnaryOperations(org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator op, MatrixValue result, int blockingFactorRow, int blockingFactorCol, MatrixIndexes indexesIn)`
`MatrixValue`	`aggregateUnaryOperations(org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator op, MatrixValue result, int blockingFactorRow, int blockingFactorCol, MatrixIndexes indexesIn, boolean inCP)`
`void`	`allocateDenseBlock()`
`void`	`allocateDenseBlock(boolean clearNNZ)`
`void`	`allocateDenseBlockUnsafe(int rl, int cl)` This should be called only in the read and write functions for CP This function should be called before calling any setValueDenseUnsafe()
`void`	`allocateDenseOrSparseBlock()`
`void`	`allocateSparseRowsBlock()`
`void`	`allocateSparseRowsBlock(boolean clearNNZ)`
`MatrixBlock`	`appendOperations(MatrixBlock that, MatrixBlock ret)`
`MatrixBlock`	`appendOperations(MatrixBlock that, MatrixBlock ret, boolean cbind)`
`void`	`appendOperations(MatrixValue v2, ArrayList<org.apache.sysml.runtime.matrix.mapred.IndexedMatrixValue> outlist, int blockRowFactor, int blockColFactor, boolean cbind, boolean m2IsLast, int nextNCol)`
`void`	`appendRow(int r, SparseRow row)`
`void`	`appendToSparse(MatrixBlock that, int rowoffset, int coloffset)`
`void`	`appendToSparse(MatrixBlock that, int rowoffset, int coloffset, boolean deep)`
`void`	`appendValue(int r, int c, double v)` Append value is only used when values are appended at the end of each row for the sparse representation This can only be called, when the caller knows the access pattern of the block
`MatrixValue`	`binaryOperations(org.apache.sysml.runtime.matrix.operators.BinaryOperator op, MatrixValue thatValue, MatrixValue result)`
`void`	`binaryOperationsInPlace(org.apache.sysml.runtime.matrix.operators.BinaryOperator op, MatrixValue thatValue)`
`MatrixBlock`	`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, org.apache.sysml.lops.MapMultChain.ChainType ctype)`
`MatrixBlock`	`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, org.apache.sysml.lops.MapMultChain.ChainType ctype, int k)`
`void`	`checkNonZeros()` Basic debugging primitive to check correctness of nnz.
`void`	`checkSparseRows()` Basic debugging primitive to check sparse block column ordering.
`void`	`cleanupBlock(boolean dense, boolean sparse)` Allows to cleanup all previously allocated sparserows or denseblocks.
`org.apache.sysml.runtime.instructions.cp.CM_COV_Object`	`cmOperations(org.apache.sysml.runtime.matrix.operators.CMOperator op)`
`org.apache.sysml.runtime.instructions.cp.CM_COV_Object`	`cmOperations(org.apache.sysml.runtime.matrix.operators.CMOperator op, MatrixBlock weights)`
`void`	`compactEmptyBlock()` Free unnecessarily allocated empty block.
`int`	`compareTo(Object arg0)`
`void`	`copy(int rl, int ru, int cl, int cu, MatrixBlock src, boolean awareDestNZ)` In-place copy of matrix src into the index range of the existing current matrix.
`void`	`copy(MatrixValue thatValue)`
`void`	`copy(MatrixValue thatValue, boolean sp)`
`org.apache.sysml.runtime.instructions.cp.CM_COV_Object`	`covOperations(org.apache.sysml.runtime.matrix.operators.COVOperator op, MatrixBlock that)`
`org.apache.sysml.runtime.instructions.cp.CM_COV_Object`	`covOperations(org.apache.sysml.runtime.matrix.operators.COVOperator op, MatrixBlock that, MatrixBlock weights)`
`void`	`dropLastRowsOrColums(org.apache.sysml.lops.PartialAggregate.CorrectionLocationType correctionLocation)`
`boolean`	`equals(Object arg0)`
`static long`	`estimateSizeDenseInMemory(long nrows, long ncols)`
`long`	`estimateSizeInMemory()`
`static long`	`estimateSizeInMemory(long nrows, long ncols, double sparsity)`
`long`	`estimateSizeOnDisk()`
`static long`	`estimateSizeOnDisk(long nrows, long ncols, long nnz)`
`static long`	`estimateSizeSparseInMemory(long nrows, long ncols, double sparsity)`
`static MatrixBlock.SparsityEstimate`	`estimateSparsityOnAggBinary(MatrixBlock m1, MatrixBlock m2, org.apache.sysml.runtime.matrix.operators.AggregateBinaryOperator op)`
`boolean`	`evalSparseFormatInMemory()` Evaluates if this matrix block should be in sparse format in memory.
`static boolean`	`evalSparseFormatInMemory(long nrows, long ncols, long nnz)` Evaluates if a matrix block with the given characteristics should be in sparse format in memory.
`boolean`	`evalSparseFormatOnDisk()` Evaluates if this matrix block should be in sparse format on disk.
`static boolean`	`evalSparseFormatOnDisk(long nrows, long ncols, long nnz)` Evaluates if a matrix block with the given characteristics should be in sparse format on disk (or in any other serialized representation).
`void`	`examSparsity()` Evaluates if this matrix block should be in sparse format in memory.
`double[]`	`getDenseBlock()`
`long`	`getExactSerializedSize()` Get the exact serialized size in bytes of the cache block.
`long`	`getExactSizeOnDisk()` NOTE: The used estimates must be kept consistent with the respective write functions.
`long`	`getInMemorySize()` Get the in-memory size in bytes of the cache block.
`long`	`getNonZeros()`
`int`	`getNumColumns()`
`int`	`getNumRows()`
`SparseBlock`	`getSparseBlock()`
`Iterator<IJV>`	`getSparseBlockIterator()`
`Iterator<IJV>`	`getSparseBlockIterator(int rl, int ru)`
`double`	`getValue(int r, int c)`
`double`	`getValueDenseUnsafe(int r, int c)`
`double`	`getValueSparseUnsafe(int r, int c)`
`MatrixBlock`	`groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, org.apache.sysml.runtime.matrix.operators.Operator op)` Invocation from CP instructions.
`MatrixBlock`	`groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, org.apache.sysml.runtime.matrix.operators.Operator op, int k)`
`int`	`hashCode()`
`void`	`incrementalAggregate(org.apache.sysml.runtime.matrix.operators.AggregateOperator aggOp, MatrixValue newWithCorrection)`
`void`	`incrementalAggregate(org.apache.sysml.runtime.matrix.operators.AggregateOperator aggOp, MatrixValue correction, MatrixValue newWithCorrection)`
`void`	`init(double[][] arr, int r, int c)` NOTE: This method is designed only for dense representation.
`void`	`init(double[] arr, int r, int c)` NOTE: This method is designed only for dense representation.
`double`	`interQuartileMean()`
`double`	`interQuartileMeanOLD()` Computes the weighted interQuartileMean.
`boolean`	`isAllocated()`
`boolean`	`isDiag()`
`boolean`	`isEmpty()`
`boolean`	`isEmptyBlock()`
`boolean`	`isEmptyBlock(boolean safe)`
`boolean`	`isInSparseFormat()` Returns the current representation (true for sparse).
`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`	`isThreadSafe()` Indicates if concurrent modifications of disjoint rows are thread-safe.
`static boolean`	`isThreadSafe(boolean sparse)` Indicates if concurrent modifications of disjoint rows are thread-safe.
`boolean`	`isUltraSparse()`
`boolean`	`isVector()`
`MatrixBlock`	`leftIndexingOperations(MatrixBlock rhsMatrix, org.apache.sysml.runtime.util.IndexRange ixrange, MatrixBlock ret, org.apache.sysml.runtime.controlprogram.caching.MatrixObject.UpdateType update)`
`MatrixBlock`	`leftIndexingOperations(MatrixBlock rhsMatrix, int rl, int ru, int cl, int cu, MatrixBlock ret, org.apache.sysml.runtime.controlprogram.caching.MatrixObject.UpdateType update)` Method to perform leftIndexing operation for a given lower and upper bounds in row and column dimensions.
`MatrixBlock`	`leftIndexingOperations(org.apache.sysml.runtime.instructions.cp.ScalarObject scalar, int rl, int cl, MatrixBlock ret, org.apache.sysml.runtime.controlprogram.caching.MatrixObject.UpdateType update)` Explicitly allow left indexing for scalars.
`double`	`max()` Wrapper method for reduceall-max of a matrix.
`double`	`median()`
`void`	`merge(org.apache.sysml.runtime.controlprogram.caching.CacheBlock that, boolean appendOnly)` Merge the given block into the current block.
`void`	`merge(MatrixBlock that, boolean appendOnly)` Merge disjoint: merges all non-zero values of the given input into the current matrix block.
`double`	`min()` Wrapper method for reduceall-min of a matrix.
`double`	`minNonZero()` Utility function for computing the min non-zero value.
`void`	`permutationMatrixMultOperations(MatrixValue m2Val, MatrixValue out1Val, MatrixValue out2Val)`
`void`	`permutationMatrixMultOperations(MatrixValue m2Val, MatrixValue out1Val, MatrixValue out2Val, int k)`
`double`	`pickValue(double quantile)`
`double`	`pickValue(double quantile, boolean average)`
`MatrixValue`	`pickValues(MatrixValue quantiles, MatrixValue ret)`
`void`	`print()`
`MatrixValue`	`quaternaryOperations(org.apache.sysml.runtime.matrix.operators.QuaternaryOperator qop, MatrixValue um, MatrixValue vm, MatrixValue wm, MatrixValue out)`
`MatrixValue`	`quaternaryOperations(org.apache.sysml.runtime.matrix.operators.QuaternaryOperator qop, MatrixValue um, MatrixValue vm, MatrixValue wm, MatrixValue out, int k)`
`double`	`quickGetValue(int r, int c)`
`void`	`quickSetValue(int r, int c, double v)`
`static MatrixBlock`	`randOperations(int rows, int cols, double sparsity, double min, double max, String pdf, long seed)` Function to generate the random matrix with specified dimensions (block sizes are not specified).
`static MatrixBlock`	`randOperations(int rows, int cols, double sparsity, double min, double max, String pdf, long seed, int k)` Function to generate the random matrix with specified dimensions (block sizes are not specified).
`static MatrixBlock`	`randOperations(RandomMatrixGenerator rgen, long seed)` Function to generate the random matrix with specified dimensions and block dimensions.
`static MatrixBlock`	`randOperations(RandomMatrixGenerator rgen, long seed, int k)` Function to generate the random matrix with specified dimensions and block dimensions.
`MatrixBlock`	`randOperationsInPlace(RandomMatrixGenerator rgen, LongStream nnzInBlock, org.apache.commons.math3.random.Well1024a bigrand, long bSeed)` Function to generate a matrix of random numbers.
`MatrixBlock`	`randOperationsInPlace(RandomMatrixGenerator rgen, LongStream nnzInBlock, org.apache.commons.math3.random.Well1024a bigrand, long bSeed, int k)` Function to generate a matrix of random numbers.
`void`	`readExternal(ObjectInput is)` Redirects the default java serialization via externalizable to our default hadoop writable serialization for efficient broadcast/rdd deserialization.
`void`	`readFields(DataInput in)`
`void`	`recomputeNonZeros()` Recomputes and materializes the number of non-zero values of the entire matrix block.
`long`	`recomputeNonZeros(int rl, int ru, int cl, int cu)` Recomputes the number of non-zero values of a specified range of the matrix block.
`MatrixBlock`	`removeEmptyOperations(MatrixBlock ret, boolean rows)`
`MatrixBlock`	`removeEmptyOperations(MatrixBlock ret, boolean rows, MatrixBlock select)`
`MatrixValue`	`reorgOperations(org.apache.sysml.runtime.matrix.operators.ReorgOperator op, MatrixValue ret, int startRow, int startColumn, int length)`
`MatrixValue`	`replaceOperations(MatrixValue result, double pattern, double replacement)`
`void`	`reset()`
`void`	`reset(int rl, int cl)`
`void`	`reset(int rl, int cl, boolean sp)`
`void`	`reset(int rl, int cl, boolean sp, long estnnz)`
`void`	`reset(int rl, int cl, double val)`
`void`	`reset(int rl, int cl, long estnnz)`
`MatrixBlock`	`rexpandOperations(MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore)`
`static MatrixBlock`	`sampleOperations(long range, int size, boolean replace, long seed)`
`MatrixValue`	`scalarOperations(org.apache.sysml.runtime.matrix.operators.ScalarOperator op, MatrixValue result)`
`static MatrixBlock`	`seqOperations(double from, double to, double incr)` Method to generate a sequence according to the given parameters.
`MatrixBlock`	`seqOperationsInPlace(double from, double to, double incr)`
`void`	`setDiag()`
`void`	`setNonZeros(long nnz)`
`void`	`setNumColumns(int c)`
`void`	`setNumRows(int r)` NOTE: setNumRows() and setNumColumns() are used only in tertiaryInstruction (for contingency tables) and pmm for meta corrections.
`void`	`setValue(int r, int c, double v)`
`void`	`setValueDenseUnsafe(int r, int c, double v)` This can be only called when you know you have properly allocated spaces for a dense representation and r and c are in the the range of the dimension Note: this function won't keep track of the nozeros
`void`	`sliceOperations(ArrayList<org.apache.sysml.runtime.matrix.mapred.IndexedMatrixValue> outlist, org.apache.sysml.runtime.util.IndexRange range, int rowCut, int colCut, int normalBlockRowFactor, int normalBlockColFactor, int boundaryRlen, int boundaryClen)`
`MatrixBlock`	`sliceOperations(org.apache.sysml.runtime.util.IndexRange ixrange, MatrixBlock ret)`
`MatrixBlock`	`sliceOperations(int rl, int ru, int cl, int cu, org.apache.sysml.runtime.controlprogram.caching.CacheBlock ret)` Method to perform rangeReIndex operation for a given lower and upper bounds in row and column dimensions.
`MatrixValue`	`sortOperations(MatrixValue weights, MatrixValue result)`
`void`	`sortSparseRows()` Sorts all existing sparse rows by column indexes.
`void`	`sortSparseRows(int rl, int ru)` Sorts all existing sparse rows in range [rl,ru) by column indexes.
`void`	`sparseToDense()`
`double`	`sum()` Wrapper method for reduceall-sum of a matrix.
`double`	`sumSq()` Wrapper method for reduceall-sumSq of a matrix.
`void`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, double scalarThat, double scalarThat2, 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`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, double scalarThat, MatrixValue that2Val, 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`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, MatrixIndexes ix1, double scalarThat, boolean left, int brlen, CTableMap resultMap, MatrixBlock resultBlock)` Specific ctable case of ctable(seq(...),X), where X is the only matrix input.
`void`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, MatrixValue thatVal, double scalarThat2, 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`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, MatrixValue thatMatrix, double thatScalar, 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)
`void`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, MatrixValue thatVal, MatrixValue that2Val, 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`	`ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op, MatrixValue thatVal, MatrixValue that2Val, CTableMap resultMap, MatrixBlock resultBlock)`
`String`	`toString()`
`MatrixBlock`	`transposeSelfMatrixMultOperations(MatrixBlock out, org.apache.sysml.lops.MMTSJ.MMTSJType tstype)`
`MatrixBlock`	`transposeSelfMatrixMultOperations(MatrixBlock out, org.apache.sysml.lops.MMTSJ.MMTSJType tstype, int k)`
`MatrixBlock`	`uaggouterchainOperations(MatrixBlock mbLeft, MatrixBlock mbRight, MatrixBlock mbOut, org.apache.sysml.runtime.matrix.operators.BinaryOperator bOp, org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator uaggOp)`
`MatrixValue`	`unaryOperations(org.apache.sysml.runtime.matrix.operators.UnaryOperator op, MatrixValue result)`
`void`	`unaryOperationsInPlace(org.apache.sysml.runtime.matrix.operators.UnaryOperator op)`
`void`	`write(DataOutput out)`
`void`	`writeExternal(ObjectOutput os)` Redirects the default java serialization via externalizable to our default hadoop writable serialization for efficient broadcast/rdd serialization.
`MatrixValue`	`zeroOutOperations(MatrixValue result, org.apache.sysml.runtime.util.IndexRange range, boolean complementary)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

SPARSITY_TURN_POINT
```
public static final double SPARSITY_TURN_POINT
```
See Also:

Constant Field Values

ULTRA_SPARSITY_TURN_POINT
```
public static final double ULTRA_SPARSITY_TURN_POINT
```
See Also:

Constant Field Values

DEFAULT_SPARSEBLOCK

public static final SparseBlock.Type DEFAULT_SPARSEBLOCK

DEFAULT_INPLACE_SPARSEBLOCK

public static final SparseBlock.Type DEFAULT_INPLACE_SPARSEBLOCK

HEADER_SIZE
```
public static final int HEADER_SIZE
```
See Also:

Constant Field Values

rlen
```
protected int rlen
```

clen
```
protected int clen
```

sparse
```
protected boolean sparse
```

nonZeros
```
protected long nonZeros
```

denseBlock
```
protected double[] denseBlock
```

sparseBlock
```
protected SparseBlock sparseBlock
```

estimatedNNzsPerRow
```
protected int estimatedNNzsPerRow
```

numGroups
```
protected int numGroups
```

diag
```
protected boolean diag
```

Constructor Detail

MatrixBlock
```
public MatrixBlock()
```

MatrixBlock

public MatrixBlock(int rl,
                   int cl,
                   boolean sp)

MatrixBlock

public MatrixBlock(int rl,
                   int cl,
                   long estnnz)

MatrixBlock

public MatrixBlock(int rl,
                   int cl,
                   boolean sp,
                   long estnnz)

MatrixBlock
```
public MatrixBlock(MatrixBlock that)
```

MatrixBlock
```
public MatrixBlock(int rl,
                   int cl,
                   long nnz,
                   SparseBlock sblock)
```
Constructs a sparse MatrixBlock with a given instance of a SparseBlock

Parameters:

rl - number of rows

cl - number of columns

nnz - number of non zeroes

sblock - sparse block

MatrixBlock

public MatrixBlock(MatrixBlock that,
                   SparseBlock.Type stype,
                   boolean deep)

Method Detail

reset
```
public void reset()
```
Specified by:

reset in class MatrixValue

reset

public void reset(int rl,
                  int cl)

Specified by:: reset in class MatrixValue

reset

public void reset(int rl,
                  int cl,
                  long estnnz)

reset

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

Specified by:: reset in class MatrixValue

reset

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

Specified by:: reset in class MatrixValue

reset

public void reset(int rl,
                  int cl,
                  double val)

Specified by:: reset in class MatrixValue

init
```
public void init(double[][] arr,
                 int r,
                 int c)
          throws DMLRuntimeException
```
NOTE: This method is designed only for dense representation.

Parameters:

arr - 2d double array matrix

r - number of rows

c - number of columns

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

init
```
public void init(double[] arr,
                 int r,
                 int c)
          throws DMLRuntimeException
```
NOTE: This method is designed only for dense representation.

Parameters:

arr - double array matrix

r - number of rows

c - number of columns

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

isAllocated
```
public boolean isAllocated()
```

allocateDenseBlock

public void allocateDenseBlock()
                        throws RuntimeException

Throws:: RuntimeException

allocateDenseOrSparseBlock

public void allocateDenseOrSparseBlock()

allocateDenseBlock

public void allocateDenseBlock(boolean clearNNZ)
                        throws RuntimeException

Throws:: RuntimeException

allocateSparseRowsBlock
```
public void allocateSparseRowsBlock()
```

allocateSparseRowsBlock

public void allocateSparseRowsBlock(boolean clearNNZ)

allocateDenseBlockUnsafe
```
public void allocateDenseBlockUnsafe(int rl,
                                     int cl)
                              throws DMLRuntimeException
```
This should be called only in the read and write functions for CP This function should be called before calling any setValueDenseUnsafe()

Parameters:

rl - number of rows

cl - number of columns

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

cleanupBlock
```
public void cleanupBlock(boolean dense,
                         boolean sparse)
```
Allows to cleanup all previously allocated sparserows or denseblocks. This is for example required in reading a matrix with many empty blocks via distributed cache into in-memory list of blocks - not cleaning blocks from non-empty blocks would significantly increase the total memory consumption.

Parameters:

dense - if true, set dense block to null

sparse - if true, set sparse block to null

getNumRows
```
public int getNumRows()
```
Specified by:

getNumRows in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Specified by:

getNumRows in class MatrixValue

setNumRows
```
public void setNumRows(int r)
```
NOTE: setNumRows() and setNumColumns() are used only in tertiaryInstruction (for contingency tables) and pmm for meta corrections.

Parameters:

r - number of rows

getNumColumns
```
public int getNumColumns()
```
Specified by:

getNumColumns in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Specified by:

getNumColumns in class MatrixValue

setNumColumns
```
public void setNumColumns(int c)
```

getNonZeros
```
public long getNonZeros()
```
Specified by:

getNonZeros in class MatrixValue

setNonZeros
```
public void setNonZeros(long nnz)
```

isVector
```
public boolean isVector()
```

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in class MatrixValue

isEmptyBlock
```
public boolean isEmptyBlock()
```

isEmptyBlock

public boolean isEmptyBlock(boolean safe)

setDiag
```
public void setDiag()
```

isDiag
```
public boolean isDiag()
```

getDenseBlock
```
public double[] getDenseBlock()
```

getSparseBlock
```
public SparseBlock getSparseBlock()
```

getSparseBlockIterator

public Iterator<IJV> getSparseBlockIterator()

getSparseBlockIterator

public Iterator<IJV> getSparseBlockIterator(int rl,
                                            int ru)

getValue

public double getValue(int r,
                       int c)

Specified by:: getValue in class MatrixValue

setValue

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

Specified by:: setValue in class MatrixValue

quickGetValue

public double quickGetValue(int r,
                            int c)

quickSetValue

public void quickSetValue(int r,
                          int c,
                          double v)

getValueDenseUnsafe

public double getValueDenseUnsafe(int r,
                                  int c)

setValueDenseUnsafe
```
public void setValueDenseUnsafe(int r,
                                int c,
                                double v)
```
This can be only called when you know you have properly allocated spaces for a dense representation and r and c are in the the range of the dimension Note: this function won't keep track of the nozeros

Parameters:

r - row

c - column

v - value

getValueSparseUnsafe

public double getValueSparseUnsafe(int r,
                                   int c)

appendValue
```
public void appendValue(int r,
                        int c,
                        double v)
```
Append value is only used when values are appended at the end of each row for the sparse representation This can only be called, when the caller knows the access pattern of the block

Parameters:

r - row

c - column

v - value

appendRow

public void appendRow(int r,
                      SparseRow row)

appendToSparse

public void appendToSparse(MatrixBlock that,
                           int rowoffset,
                           int coloffset)

appendToSparse

public void appendToSparse(MatrixBlock that,
                           int rowoffset,
                           int coloffset,
                           boolean deep)

sortSparseRows
```
public void sortSparseRows()
```
Sorts all existing sparse rows by column indexes.

sortSparseRows
```
public void sortSparseRows(int rl,
                           int ru)
```
Sorts all existing sparse rows in range [rl,ru) by column indexes.

Parameters:

rl - row lower bound, inclusive

ru - row upper bound, exclusive

minNonZero
```
public double minNonZero()
                  throws DMLRuntimeException
```
Utility function for computing the min non-zero value.

Returns:

minimum non-zero value

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

min
```
public double min()
           throws DMLRuntimeException
```
Wrapper method for reduceall-min of a matrix.

Returns:

?

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

max
```
public double max()
           throws DMLRuntimeException
```
Wrapper method for reduceall-max of a matrix.

Returns:

?

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

sum
```
public double sum()
           throws DMLRuntimeException
```
Wrapper method for reduceall-sum of a matrix.

Returns:

Sum of the values in the matrix.

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

sumSq
```
public double sumSq()
             throws DMLRuntimeException
```
Wrapper method for reduceall-sumSq of a matrix.

Returns:

Sum of the squared values in the matrix.

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

isInSparseFormat
```
public boolean isInSparseFormat()
```
Returns the current representation (true for sparse).

Specified by:

isInSparseFormat in class MatrixValue

Returns:

true if sparse

isUltraSparse
```
public boolean isUltraSparse()
```

evalSparseFormatInMemory
```
public boolean evalSparseFormatInMemory()
```
Evaluates if this matrix block should be in sparse format in memory. Note that this call does not change the representation - for this please call examSparsity.

Returns:

true if matrix block should be in sparse format in memory

evalSparseFormatOnDisk
```
public boolean evalSparseFormatOnDisk()
```
Evaluates if this matrix block should be in sparse format on disk. This applies to any serialized matrix representation, i.e., when writing to in-memory buffer pool pages or writing to local fs or hdfs.

Returns:

true if matrix block should be in sparse format on disk

examSparsity
```
public void examSparsity()
                  throws DMLRuntimeException
```
Evaluates if this matrix block should be in sparse format in memory. Depending on the current representation, the state of the matrix block is changed to the right representation if necessary. Note that this consumes for the time of execution memory for both representations.

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

evalSparseFormatInMemory
```
public static boolean evalSparseFormatInMemory(long nrows,
                                               long ncols,
                                               long nnz)
```
Evaluates if a matrix block with the given characteristics should be in sparse format in memory.

Parameters:

nrows - number of rows

ncols - number of columns

nnz - number of non-zeros

Returns:

true if matrix block shold be in sparse format in memory

evalSparseFormatOnDisk
```
public static boolean evalSparseFormatOnDisk(long nrows,
                                             long ncols,
                                             long nnz)
```
Evaluates if a matrix block with the given characteristics should be in sparse format on disk (or in any other serialized representation).

Parameters:

nrows - number of rows

ncols - number of columns

nnz - number of non-zeros

Returns:

true if matrix block shold be in sparse format on disk

sparseToDense

public void sparseToDense()
                   throws DMLRuntimeException

Throws:: DMLRuntimeException

recomputeNonZeros
```
public void recomputeNonZeros()
```
Recomputes and materializes the number of non-zero values of the entire matrix block.

recomputeNonZeros
```
public long recomputeNonZeros(int rl,
                              int ru,
                              int cl,
                              int cu)
```
Recomputes the number of non-zero values of a specified range of the matrix block. NOTE: This call does not materialize the compute result in any form.

Parameters:

rl - row lower index, 0-based, inclusive

ru - row upper index, 0-based, inclusive

cl - column lower index, 0-based, inclusive

cu - column upper index, 0-based, inclusive

Returns:

the number of non-zero values

checkNonZeros
```
public void checkNonZeros()
```
Basic debugging primitive to check correctness of nnz. This method is not intended for production use.

checkSparseRows
```
public void checkSparseRows()
```
Basic debugging primitive to check sparse block column ordering. This method is not intended for production use.

copy

public void copy(MatrixValue thatValue)

Specified by:: copy in class MatrixValue

copy

public void copy(MatrixValue thatValue,
                 boolean sp)

Specified by:: copy in class MatrixValue

copy
```
public void copy(int rl,
                 int ru,
                 int cl,
                 int cu,
                 MatrixBlock src,
                 boolean awareDestNZ)
          throws DMLRuntimeException
```
In-place copy of matrix src into the index range of the existing current matrix. Note that removal of existing nnz in the index range and nnz maintenance is only done if 'awareDestNZ=true',

Parameters:

rl - row lower index, 0-based

ru - row upper index, 0-based

cl - column lower index, 0-based

cu - column upper index, 0-based

src - matrix block

awareDestNZ - true, forces (1) to remove existing non-zeros in the index range of the destination if not present in src and (2) to internally maintain nnz false, assume empty index range in destination and do not maintain nnz (the invoker is responsible to recompute nnz after all copies are done)

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

merge
```
public void merge(org.apache.sysml.runtime.controlprogram.caching.CacheBlock that,
                  boolean appendOnly)
           throws DMLRuntimeException
```
Description copied from interface: org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Merge the given block into the current block. Both blocks needs to be of equal dimensions and contain disjoint non-zero cells.

Specified by:

merge in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Parameters:

that - cache block

appendOnly - ?

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

merge
```
public void merge(MatrixBlock that,
                  boolean appendOnly)
           throws DMLRuntimeException
```
Merge disjoint: merges all non-zero values of the given input into the current matrix block. Note that this method does NOT check for overlapping entries; it's the callers reponsibility of ensuring disjoint matrix blocks. The appendOnly parameter is only relevant for sparse target blocks; if true, we only append values and do not sort sparse rows for each call; this is useful whenever we merge iterators of matrix blocks into one target block.

Parameters:

that - matrix block

appendOnly - ?

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

readFields
```
public void readFields(DataInput in)
                throws IOException
```
Specified by:

readFields in interface org.apache.hadoop.io.Writable

Throws:

IOException

write
```
public void write(DataOutput out)
           throws IOException
```
Specified by:

write in interface org.apache.hadoop.io.Writable

Throws:

IOException

readExternal
```
public void readExternal(ObjectInput is)
                  throws IOException
```
Redirects the default java serialization via externalizable to our default hadoop writable serialization for efficient broadcast/rdd deserialization.

Specified by:

readExternal in interface Externalizable

Parameters:

is - object input

Throws:

IOException - if IOException occurs

writeExternal
```
public void writeExternal(ObjectOutput os)
                   throws IOException
```
Redirects the default java serialization via externalizable to our default hadoop writable serialization for efficient broadcast/rdd serialization.

Specified by:

writeExternal in interface Externalizable

Parameters:

os - object output

Throws:

IOException - if IOException occurs

getExactSizeOnDisk
```
public long getExactSizeOnDisk()
```
NOTE: The used estimates must be kept consistent with the respective write functions.

Returns:

exact size on disk

estimateSizeInMemory
```
public long estimateSizeInMemory()
```

estimateSizeInMemory

public static long estimateSizeInMemory(long nrows,
                                        long ncols,
                                        double sparsity)

estimateSizeDenseInMemory

public static long estimateSizeDenseInMemory(long nrows,
                                             long ncols)

estimateSizeSparseInMemory

public static long estimateSizeSparseInMemory(long nrows,
                                              long ncols,
                                              double sparsity)

estimateSizeOnDisk
```
public long estimateSizeOnDisk()
```

estimateSizeOnDisk

public static long estimateSizeOnDisk(long nrows,
                                      long ncols,
                                      long nnz)

estimateSparsityOnAggBinary

public static MatrixBlock.SparsityEstimate estimateSparsityOnAggBinary(MatrixBlock m1,
                                                                       MatrixBlock m2,
                                                                       org.apache.sysml.runtime.matrix.operators.AggregateBinaryOperator op)

getInMemorySize
```
public long getInMemorySize()
```
Description copied from interface: org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Get the in-memory size in bytes of the cache block.

Specified by:

getInMemorySize in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Returns:

in-memory size in bytes of cache block

getExactSerializedSize
```
public long getExactSerializedSize()
```
Description copied from interface: org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Get the exact serialized size in bytes of the cache block.

Specified by:

getExactSerializedSize in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Returns:

exact serialized size in bytes of cache block

isShallowSerialize
```
public boolean isShallowSerialize()
```
Description copied from interface: org.apache.sysml.runtime.controlprogram.caching.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 org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Returns:

true if shallow serialized

compactEmptyBlock
```
public void compactEmptyBlock()
```
Description copied from interface: org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Free unnecessarily allocated empty block.

Specified by:

compactEmptyBlock in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

scalarOperations

public MatrixValue scalarOperations(org.apache.sysml.runtime.matrix.operators.ScalarOperator op,
                                    MatrixValue result)
                             throws DMLRuntimeException

Specified by:: scalarOperations in class MatrixValue
Throws:: DMLRuntimeException

unaryOperations

public MatrixValue unaryOperations(org.apache.sysml.runtime.matrix.operators.UnaryOperator op,
                                   MatrixValue result)
                            throws DMLRuntimeException

Specified by:: unaryOperations in class MatrixValue
Throws:: DMLRuntimeException

unaryOperationsInPlace

public void unaryOperationsInPlace(org.apache.sysml.runtime.matrix.operators.UnaryOperator op)
                            throws DMLRuntimeException

Specified by:: unaryOperationsInPlace in class MatrixValue
Throws:: DMLRuntimeException

binaryOperations

public MatrixValue binaryOperations(org.apache.sysml.runtime.matrix.operators.BinaryOperator op,
                                    MatrixValue thatValue,
                                    MatrixValue result)
                             throws DMLRuntimeException

Specified by:: binaryOperations in class MatrixValue
Throws:: DMLRuntimeException

binaryOperationsInPlace

public void binaryOperationsInPlace(org.apache.sysml.runtime.matrix.operators.BinaryOperator op,
                                    MatrixValue thatValue)
                             throws DMLRuntimeException

Specified by:: binaryOperationsInPlace in class MatrixValue
Throws:: DMLRuntimeException

incrementalAggregate

public void incrementalAggregate(org.apache.sysml.runtime.matrix.operators.AggregateOperator aggOp,
                                 MatrixValue correction,
                                 MatrixValue newWithCorrection)
                          throws DMLRuntimeException

Specified by:: incrementalAggregate in class MatrixValue
Throws:: DMLRuntimeException

incrementalAggregate

public void incrementalAggregate(org.apache.sysml.runtime.matrix.operators.AggregateOperator aggOp,
                                 MatrixValue newWithCorrection)
                          throws DMLRuntimeException

Specified by:: incrementalAggregate in class MatrixValue
Throws:: DMLRuntimeException

reorgOperations

public MatrixValue reorgOperations(org.apache.sysml.runtime.matrix.operators.ReorgOperator op,
                                   MatrixValue ret,
                                   int startRow,
                                   int startColumn,
                                   int length)
                            throws DMLRuntimeException

Specified by:: reorgOperations in class MatrixValue
Throws:: DMLRuntimeException

appendOperations

public MatrixBlock appendOperations(MatrixBlock that,
                                    MatrixBlock ret)
                             throws DMLRuntimeException

Throws:: DMLRuntimeException

appendOperations

public MatrixBlock appendOperations(MatrixBlock that,
                                    MatrixBlock ret,
                                    boolean cbind)
                             throws DMLRuntimeException

Throws:: DMLRuntimeException

transposeSelfMatrixMultOperations

public MatrixBlock transposeSelfMatrixMultOperations(MatrixBlock out,
                                                     org.apache.sysml.lops.MMTSJ.MMTSJType tstype)
                                              throws DMLRuntimeException

Throws:: DMLRuntimeException

transposeSelfMatrixMultOperations

public MatrixBlock transposeSelfMatrixMultOperations(MatrixBlock out,
                                                     org.apache.sysml.lops.MMTSJ.MMTSJType tstype,
                                                     int k)
                                              throws DMLRuntimeException

Throws:: DMLRuntimeException

chainMatrixMultOperations

public MatrixBlock chainMatrixMultOperations(MatrixBlock v,
                                             MatrixBlock w,
                                             MatrixBlock out,
                                             org.apache.sysml.lops.MapMultChain.ChainType ctype)
                                      throws DMLRuntimeException

Throws:: DMLRuntimeException

chainMatrixMultOperations

public MatrixBlock chainMatrixMultOperations(MatrixBlock v,
                                             MatrixBlock w,
                                             MatrixBlock out,
                                             org.apache.sysml.lops.MapMultChain.ChainType ctype,
                                             int k)
                                      throws DMLRuntimeException

Throws:: DMLRuntimeException

permutationMatrixMultOperations

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

Throws:: DMLRuntimeException

permutationMatrixMultOperations

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

Throws:: DMLRuntimeException

leftIndexingOperations

public final MatrixBlock leftIndexingOperations(MatrixBlock rhsMatrix,
                                                org.apache.sysml.runtime.util.IndexRange ixrange,
                                                MatrixBlock ret,
                                                org.apache.sysml.runtime.controlprogram.caching.MatrixObject.UpdateType update)
                                         throws DMLRuntimeException

Throws:: DMLRuntimeException

leftIndexingOperations

public MatrixBlock leftIndexingOperations(MatrixBlock rhsMatrix,
                                          int rl,
                                          int ru,
                                          int cl,
                                          int cu,
                                          MatrixBlock ret,
                                          org.apache.sysml.runtime.controlprogram.caching.MatrixObject.UpdateType update)
                                   throws DMLRuntimeException

Method to perform leftIndexing operation for a given lower and upper bounds in row and column dimensions. Updated matrix is returned as the output. Operations to be performed: 1) result=this; 2) result[rowLower:rowUpper, colLower:colUpper] = rhsMatrix;

Parameters:: rhsMatrix - matrix; rl - row lower; ru - row upper; cl - column lower; cu - column upper; ret - ?; update - ?
Returns:: matrix block
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

leftIndexingOperations

public MatrixBlock leftIndexingOperations(org.apache.sysml.runtime.instructions.cp.ScalarObject scalar,
                                          int rl,
                                          int cl,
                                          MatrixBlock ret,
                                          org.apache.sysml.runtime.controlprogram.caching.MatrixObject.UpdateType update)
                                   throws DMLRuntimeException

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

Parameters:: scalar - scalar object; rl - row lower; cl - column lower; ret - ?; update - ?
Returns:: matrix block
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

sliceOperations

public final MatrixBlock sliceOperations(org.apache.sysml.runtime.util.IndexRange ixrange,
                                         MatrixBlock ret)
                                  throws DMLRuntimeException

Throws:: DMLRuntimeException

sliceOperations
```
public MatrixBlock sliceOperations(int rl,
                                   int ru,
                                   int cl,
                                   int cu,
                                   org.apache.sysml.runtime.controlprogram.caching.CacheBlock ret)
                            throws DMLRuntimeException
```
Method to perform rangeReIndex 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.

Specified by:

sliceOperations in interface org.apache.sysml.runtime.controlprogram.caching.CacheBlock

Parameters:

rl - row lower

ru - row upper

cl - column lower

cu - column upper

ret - ?

Returns:

matrix block

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

sliceOperations

public void sliceOperations(ArrayList<org.apache.sysml.runtime.matrix.mapred.IndexedMatrixValue> outlist,
                            org.apache.sysml.runtime.util.IndexRange range,
                            int rowCut,
                            int colCut,
                            int normalBlockRowFactor,
                            int normalBlockColFactor,
                            int boundaryRlen,
                            int boundaryClen)

Specified by:: sliceOperations in class MatrixValue

appendOperations

public void appendOperations(MatrixValue v2,
                             ArrayList<org.apache.sysml.runtime.matrix.mapred.IndexedMatrixValue> outlist,
                             int blockRowFactor,
                             int blockColFactor,
                             boolean cbind,
                             boolean m2IsLast,
                             int nextNCol)
                      throws DMLRuntimeException

Specified by:: appendOperations in class MatrixValue
Throws:: DMLRuntimeException

zeroOutOperations

public MatrixValue zeroOutOperations(MatrixValue result,
                                     org.apache.sysml.runtime.util.IndexRange range,
                                     boolean complementary)
                              throws DMLRuntimeException

Specified by:: zeroOutOperations in class MatrixValue
Throws:: DMLRuntimeException

aggregateUnaryOperations

public MatrixValue aggregateUnaryOperations(org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator op,
                                            MatrixValue result,
                                            int blockingFactorRow,
                                            int blockingFactorCol,
                                            MatrixIndexes indexesIn)
                                     throws DMLRuntimeException

Specified by:: aggregateUnaryOperations in class MatrixValue
Throws:: DMLRuntimeException

aggregateUnaryOperations

public MatrixValue aggregateUnaryOperations(org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator op,
                                            MatrixValue result,
                                            int blockingFactorRow,
                                            int blockingFactorCol,
                                            MatrixIndexes indexesIn,
                                            boolean inCP)
                                     throws DMLRuntimeException

Specified by:: aggregateUnaryOperations in class MatrixValue
Throws:: DMLRuntimeException

dropLastRowsOrColums

public void dropLastRowsOrColums(org.apache.sysml.lops.PartialAggregate.CorrectionLocationType correctionLocation)

cmOperations

public org.apache.sysml.runtime.instructions.cp.CM_COV_Object cmOperations(org.apache.sysml.runtime.matrix.operators.CMOperator op)
                                                                    throws DMLRuntimeException

Throws:: DMLRuntimeException

cmOperations

public org.apache.sysml.runtime.instructions.cp.CM_COV_Object cmOperations(org.apache.sysml.runtime.matrix.operators.CMOperator op,
                                                                           MatrixBlock weights)
                                                                    throws DMLRuntimeException

Throws:: DMLRuntimeException

covOperations

public org.apache.sysml.runtime.instructions.cp.CM_COV_Object covOperations(org.apache.sysml.runtime.matrix.operators.COVOperator op,
                                                                            MatrixBlock that)
                                                                     throws DMLRuntimeException

Throws:: DMLRuntimeException

covOperations

public org.apache.sysml.runtime.instructions.cp.CM_COV_Object covOperations(org.apache.sysml.runtime.matrix.operators.COVOperator op,
                                                                            MatrixBlock that,
                                                                            MatrixBlock weights)
                                                                     throws DMLRuntimeException

Throws:: DMLRuntimeException

sortOperations

public MatrixValue sortOperations(MatrixValue weights,
                                  MatrixValue result)
                           throws DMLRuntimeException

Throws:: DMLRuntimeException

interQuartileMean

public double interQuartileMean()
                         throws DMLRuntimeException

Throws:: DMLRuntimeException

interQuartileMeanOLD
```
public double interQuartileMeanOLD()
                            throws DMLRuntimeException
```
Computes the weighted interQuartileMean. The matrix block ("this" pointer) has two columns, in which the first column refers to the data and second column denotes corresponding weights.

Returns:

InterQuartileMean

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

pickValues

public MatrixValue pickValues(MatrixValue quantiles,
                              MatrixValue ret)
                       throws DMLRuntimeException

Throws:: DMLRuntimeException

median

public double median()
              throws DMLRuntimeException

Throws:: DMLRuntimeException

pickValue

public double pickValue(double quantile)
                 throws DMLRuntimeException

Throws:: DMLRuntimeException

pickValue

public double pickValue(double quantile,
                        boolean average)
                 throws DMLRuntimeException

Throws:: DMLRuntimeException

aggregateBinaryOperations

public MatrixValue aggregateBinaryOperations(MatrixIndexes m1Index,
                                             MatrixValue m1Value,
                                             MatrixIndexes m2Index,
                                             MatrixValue m2Value,
                                             MatrixValue result,
                                             org.apache.sysml.runtime.matrix.operators.AggregateBinaryOperator op)
                                      throws DMLRuntimeException

Specified by:: aggregateBinaryOperations in class MatrixValue
Throws:: DMLRuntimeException

aggregateBinaryOperations

public MatrixValue aggregateBinaryOperations(MatrixValue m1Value,
                                             MatrixValue m2Value,
                                             MatrixValue result,
                                             org.apache.sysml.runtime.matrix.operators.AggregateBinaryOperator op)
                                      throws DMLRuntimeException

Specified by:: aggregateBinaryOperations in class MatrixValue
Throws:: DMLRuntimeException

aggregateTernaryOperations

public MatrixBlock aggregateTernaryOperations(MatrixBlock m1,
                                              MatrixBlock m2,
                                              MatrixBlock m3,
                                              MatrixBlock ret,
                                              org.apache.sysml.runtime.matrix.operators.AggregateTernaryOperator op,
                                              boolean inCP)
                                       throws DMLRuntimeException

Throws:: DMLRuntimeException

uaggouterchainOperations

public MatrixBlock uaggouterchainOperations(MatrixBlock mbLeft,
                                            MatrixBlock mbRight,
                                            MatrixBlock mbOut,
                                            org.apache.sysml.runtime.matrix.operators.BinaryOperator bOp,
                                            org.apache.sysml.runtime.matrix.operators.AggregateUnaryOperator uaggOp)
                                     throws DMLRuntimeException

Throws:: DMLRuntimeException

groupedAggOperations
```
public MatrixBlock groupedAggOperations(MatrixValue tgt,
                                        MatrixValue wghts,
                                        MatrixValue ret,
                                        int ngroups,
                                        org.apache.sysml.runtime.matrix.operators.Operator op)
                                 throws DMLRuntimeException
```
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.

Parameters:

tgt - ?

wghts - ?

ret - ?

ngroups - ?

op - operator

Returns:

matrix block

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

groupedAggOperations

public MatrixBlock groupedAggOperations(MatrixValue tgt,
                                        MatrixValue wghts,
                                        MatrixValue ret,
                                        int ngroups,
                                        org.apache.sysml.runtime.matrix.operators.Operator op,
                                        int k)
                                 throws DMLRuntimeException

Throws:: DMLRuntimeException

removeEmptyOperations

public MatrixBlock removeEmptyOperations(MatrixBlock ret,
                                         boolean rows,
                                         MatrixBlock select)
                                  throws DMLRuntimeException

Throws:: DMLRuntimeException

removeEmptyOperations

public MatrixBlock removeEmptyOperations(MatrixBlock ret,
                                         boolean rows)
                                  throws DMLRuntimeException

Throws:: DMLRuntimeException

rexpandOperations

public MatrixBlock rexpandOperations(MatrixBlock ret,
                                     double max,
                                     boolean rows,
                                     boolean cast,
                                     boolean ignore)
                              throws DMLRuntimeException

Throws:: DMLRuntimeException

replaceOperations

public MatrixValue replaceOperations(MatrixValue result,
                                     double pattern,
                                     double replacement)
                              throws DMLRuntimeException

Specified by:: replaceOperations in class MatrixValue
Throws:: DMLRuntimeException

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              double scalarThat,
                              MatrixValue that2Val,
                              CTableMap resultMap,
                              MatrixBlock resultBlock)
                       throws DMLRuntimeException

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)

Specified by:: ternaryOperations in class MatrixValue
Throws:: DMLRuntimeException

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              double scalarThat,
                              double scalarThat2,
                              CTableMap resultMap,
                              MatrixBlock resultBlock)
                       throws DMLRuntimeException

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)

Specified by:: ternaryOperations in class MatrixValue
Throws:: DMLRuntimeException

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              MatrixIndexes ix1,
                              double scalarThat,
                              boolean left,
                              int brlen,
                              CTableMap resultMap,
                              MatrixBlock resultBlock)
                       throws DMLRuntimeException

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.

Specified by:: ternaryOperations in class MatrixValue
Throws:: DMLRuntimeException

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              MatrixValue thatVal,
                              double scalarThat2,
                              boolean ignoreZeros,
                              CTableMap resultMap,
                              MatrixBlock resultBlock)
                       throws DMLRuntimeException

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

Specified by:: ternaryOperations in class MatrixValue
Throws:: DMLRuntimeException

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              MatrixValue thatMatrix,
                              double thatScalar,
                              MatrixBlock resultBlock)
                       throws DMLRuntimeException

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)

Parameters:: op - operator; thatMatrix - matrix value; thatScalar - scalar double; resultBlock - result matrix block
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              MatrixValue thatVal,
                              MatrixValue that2Val,
                              CTableMap resultMap)
                       throws DMLRuntimeException

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)

Parameters:: op - operator; thatVal - matrix value 1; that2Val - matrix value 2; resultMap - table map
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

ternaryOperations

public void ternaryOperations(org.apache.sysml.runtime.matrix.operators.Operator op,
                              MatrixValue thatVal,
                              MatrixValue that2Val,
                              CTableMap resultMap,
                              MatrixBlock resultBlock)
                       throws DMLRuntimeException

Specified by:: ternaryOperations in class MatrixValue
Throws:: DMLRuntimeException

quaternaryOperations

public MatrixValue quaternaryOperations(org.apache.sysml.runtime.matrix.operators.QuaternaryOperator qop,
                                        MatrixValue um,
                                        MatrixValue vm,
                                        MatrixValue wm,
                                        MatrixValue out)
                                 throws DMLRuntimeException

Specified by:: quaternaryOperations in class MatrixValue
Throws:: DMLRuntimeException

quaternaryOperations

public MatrixValue quaternaryOperations(org.apache.sysml.runtime.matrix.operators.QuaternaryOperator qop,
                                        MatrixValue um,
                                        MatrixValue vm,
                                        MatrixValue wm,
                                        MatrixValue out,
                                        int k)
                                 throws DMLRuntimeException

Throws:: DMLRuntimeException

randOperations

public static MatrixBlock randOperations(int rows,
                                         int cols,
                                         double sparsity,
                                         double min,
                                         double max,
                                         String pdf,
                                         long seed)
                                  throws DMLRuntimeException

Function to generate the random matrix with specified dimensions (block sizes are not specified).

Parameters:: rows - number of rows; cols - number of columns; sparsity - sparsity as a percentage; min - minimum value; max - maximum value; pdf - pdf; seed - random seed
Returns:: matrix block
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

randOperations

public static MatrixBlock randOperations(int rows,
                                         int cols,
                                         double sparsity,
                                         double min,
                                         double max,
                                         String pdf,
                                         long seed,
                                         int k)
                                  throws DMLRuntimeException

Function to generate the random matrix with specified dimensions (block sizes are not specified).

Parameters:: rows - number of rows; cols - number of columns; sparsity - sparsity as a percentage; min - minimum value; max - maximum value; pdf - pdf; seed - random seed; k - ?
Returns:: matrix block
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

randOperations
```
public static MatrixBlock randOperations(RandomMatrixGenerator rgen,
                                         long seed)
                                  throws DMLRuntimeException
```
Function to generate the random matrix with specified dimensions and block dimensions.

Parameters:

rgen - random matrix generator

seed - seed value

Returns:

matrix block

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

randOperations

public static MatrixBlock randOperations(RandomMatrixGenerator rgen,
                                         long seed,
                                         int k)
                                  throws DMLRuntimeException

Function to generate the random matrix with specified dimensions and block dimensions.

Parameters:: rgen - random matrix generator; seed - seed value; k - ?
Returns:: matrix block
Throws:: DMLRuntimeException - if DMLRuntimeException occurs

randOperationsInPlace
```
public MatrixBlock randOperationsInPlace(RandomMatrixGenerator rgen,
                                         LongStream nnzInBlock,
                                         org.apache.commons.math3.random.Well1024a bigrand,
                                         long bSeed)
                                  throws DMLRuntimeException
```
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).

Parameters:

rgen - random matrix generator

nnzInBlock - number of nonzeros in block

bigrand - ?

bSeed - seed value

Returns:

matrix block

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

randOperationsInPlace
```
public MatrixBlock randOperationsInPlace(RandomMatrixGenerator rgen,
                                         LongStream nnzInBlock,
                                         org.apache.commons.math3.random.Well1024a bigrand,
                                         long bSeed,
                                         int k)
                                  throws DMLRuntimeException
```
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).

Parameters:

rgen - random matrix generator

nnzInBlock - number of nonzeros in block

bigrand - ?

bSeed - seed value

k - ?

Returns:

matrix block

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

seqOperations
```
public static MatrixBlock seqOperations(double from,
                                        double to,
                                        double incr)
                                 throws DMLRuntimeException
```
Method to generate a sequence according to the given parameters. The generated sequence is always in dense format. Both end points specified from and to must be included in the generated sequence i.e., [from,to] both inclusive. Note that, to is included only if (to-from) is perfectly divisible by incr. For example, seq(0,1,0.5) generates (0.0 0.5 1.0) whereas seq(0,1,0.6) generates (0.0 0.6) but not (0.0 0.6 1.0)

Parameters:

from - ?

to - ?

incr - ?

Returns:

matrix block

Throws:

DMLRuntimeException - if DMLRuntimeException occurs

seqOperationsInPlace

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

Throws:: DMLRuntimeException

sampleOperations

public static MatrixBlock sampleOperations(long range,
                                           int size,
                                           boolean replace,
                                           long seed)
                                    throws DMLRuntimeException

Throws:: DMLRuntimeException

isThreadSafe
```
public boolean isThreadSafe()
```
Indicates if concurrent modifications of disjoint rows are thread-safe.

Returns:

true if thread-safe

isThreadSafe
```
public static boolean isThreadSafe(boolean sparse)
```
Indicates if concurrent modifications of disjoint rows are thread-safe.

Parameters:

sparse - true if sparse

Returns:

true if ?

print
```
public void print()
```

compareTo
```
public int compareTo(Object arg0)
```
Specified by:

compareTo in interface Comparable

equals
```
public boolean equals(Object arg0)
```
Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

toString
```
public String toString()
```
Overrides:

toString in class Object

Nested classes/interfaces inherited from class org.apache.sysml.runtime.matrix.data.MatrixValue

Methods inherited from class java.lang.Object

SPARSITY_TURN_POINT

ULTRA_SPARSITY_TURN_POINT

DEFAULT_SPARSEBLOCK

DEFAULT_INPLACE_SPARSEBLOCK

HEADER_SIZE

rlen

clen

sparse

nonZeros

denseBlock

sparseBlock

estimatedNNzsPerRow

numGroups

diag

MatrixBlock

MatrixBlock

MatrixBlock

MatrixBlock

MatrixBlock

MatrixBlock

MatrixBlock

reset

reset

reset

reset

reset

reset

init

init

isAllocated

allocateDenseBlock

allocateDenseOrSparseBlock

allocateDenseBlock

allocateSparseRowsBlock

allocateSparseRowsBlock

allocateDenseBlockUnsafe

cleanupBlock

getNumRows

setNumRows

getNumColumns

setNumColumns

getNonZeros

setNonZeros

isVector

isEmpty

isEmptyBlock

isEmptyBlock

setDiag

isDiag

getDenseBlock

getSparseBlock

getSparseBlockIterator

getSparseBlockIterator

getValue

setValue

quickGetValue

quickSetValue

getValueDenseUnsafe

setValueDenseUnsafe

getValueSparseUnsafe

appendValue

appendRow

appendToSparse

appendToSparse

sortSparseRows

sortSparseRows

minNonZero

min

max

sum

sumSq

isInSparseFormat

isUltraSparse

evalSparseFormatInMemory

evalSparseFormatOnDisk

examSparsity

evalSparseFormatInMemory

evalSparseFormatOnDisk