# Uses of Class
org.apache.sysds.runtime.matrix.data.MatrixBlock

Packages that use MatrixBlock
Package
Description
org.apache.sysds.api
org.apache.sysds.api.jmlc
org.apache.sysds.api.mlcontext
org.apache.sysds.hops.estim
org.apache.sysds.hops.rewrite
org.apache.sysds.runtime.codegen
org.apache.sysds.runtime.compress
org.apache.sysds.runtime.compress.bitmap
org.apache.sysds.runtime.compress.colgroup
org.apache.sysds.runtime.compress.colgroup.dictionary
org.apache.sysds.runtime.compress.colgroup.functional
org.apache.sysds.runtime.compress.colgroup.mapping
org.apache.sysds.runtime.compress.colgroup.scheme
org.apache.sysds.runtime.compress.cost
org.apache.sysds.runtime.compress.estim
org.apache.sysds.runtime.compress.estim.encoding
org.apache.sysds.runtime.compress.io
org.apache.sysds.runtime.compress.lib
org.apache.sysds.runtime.compress.plan
org.apache.sysds.runtime.compress.readers
org.apache.sysds.runtime.compress.utils
org.apache.sysds.runtime.controlprogram.caching
org.apache.sysds.runtime.controlprogram.context
org.apache.sysds.runtime.controlprogram.federated
org.apache.sysds.runtime.controlprogram.paramserv
org.apache.sysds.runtime.controlprogram.paramserv.dp
org.apache.sysds.runtime.controlprogram.parfor
org.apache.sysds.runtime.controlprogram.parfor.util
org.apache.sysds.runtime.data
org.apache.sysds.runtime.einsum
org.apache.sysds.runtime.frame.data
org.apache.sysds.runtime.frame.data.lib
org.apache.sysds.runtime.functionobjects
org.apache.sysds.runtime.instructions.cp
org.apache.sysds.runtime.instructions.fed
org.apache.sysds.runtime.instructions.ooc
org.apache.sysds.runtime.instructions.spark
org.apache.sysds.runtime.instructions.spark.data
org.apache.sysds.runtime.instructions.spark.functions
org.apache.sysds.runtime.instructions.spark.utils
org.apache.sysds.runtime.io
org.apache.sysds.runtime.iogen
org.apache.sysds.runtime.iogen.template
org.apache.sysds.runtime.lineage
org.apache.sysds.runtime.matrix.data
org.apache.sysds.runtime.matrix.data.sketch
org.apache.sysds.runtime.matrix.data.sketch.countdistinct
org.apache.sysds.runtime.matrix.data.sketch.countdistinctapprox
org.apache.sysds.runtime.matrix.operators
org.apache.sysds.runtime.transform.decode
org.apache.sysds.runtime.transform.encode
org.apache.sysds.runtime.util

## Uses of MatrixBlock in org.apache.sysds.api

Methods in org.apache.sysds.api that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
PythonDMLScript.`startReadingMbFromPipe(int id, int rlen, int clen, Types.ValueType type)`
`MatrixBlock`
PythonDMLScript.`startReadingMbFromPipes(int[] blockSizes, int rlen, int clen, Types.ValueType type)`
Methods in org.apache.sysds.api with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
PythonDMLScript.`startWritingMbToPipe(int id, MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.api.jmlc

Methods in org.apache.sysds.api.jmlc that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
Connection.`convertToMatrix(InputStream input, int rows, int cols)`
Converts an input stream of a string matrix in text format into a matrix block.
`MatrixBlock`
Connection.`convertToMatrix(InputStream input, int rows, int cols, String format)`
Converts an input stream of a string matrix in csv or text format into a matrix block.
`MatrixBlock`
Connection.`convertToMatrix(InputStream input, String meta)`
Converts an input stream of a string matrix in csv or textcell format into a matrix block.
`MatrixBlock`
Connection.`convertToMatrix(String input, int rows, int cols)`
Converts an input string representation of a matrix in textcell format into a matrix block.
`MatrixBlock`
Connection.`convertToMatrix(String input, String meta)`
Converts an input string representation of a matrix in csv or textcell format into a matrix block.
`MatrixBlock`
ResultVariables.`getMatrixBlock(String varname)`
Obtain the matrix represented by the given output variable.
Methods in org.apache.sysds.api.jmlc with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
PreparedScript.`setMatrix(String varname, MatrixBlock matrix, boolean reuse)`
Binds a matrix object to a registered input variable.

## Uses of MatrixBlock in org.apache.sysds.api.mlcontext

Methods in org.apache.sysds.api.mlcontext that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
MLContextConversionUtil.`binaryBlocksToMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> binaryBlocks, MatrixMetadata matrixMetadata)`
Convert a `JavaPairRDD<MatrixIndexes, MatrixBlock>` to a `MatrixBlock`
`MatrixBlock`
Matrix.`toMatrixBlock()`
Obtain the matrix as a `MatrixBlock`
Methods in org.apache.sysds.api.mlcontext that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
MLContextConversionUtil.`dataFrameToMatrixBinaryBlocks(org.apache.spark.sql.Dataset<org.apache.spark.sql.Row> dataFrame)`
Convert a `DataFrame` to a `JavaPairRDD<MatrixIndexes, MatrixBlock>` binary-block matrix.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
MLContextConversionUtil.`dataFrameToMatrixBinaryBlocks(org.apache.spark.sql.Dataset<org.apache.spark.sql.Row> dataFrame, MatrixMetadata matrixMetadata)`
Convert a `DataFrame` to a `JavaPairRDD<MatrixIndexes, MatrixBlock>` binary-block matrix.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
MLContextConversionUtil.`matrixObjectToBinaryBlocks(MatrixObject matrixObject, SparkExecutionContext sparkExecutionContext)`
Convert a `MatrixObject` to a `JavaPairRDD<MatrixIndexes, MatrixBlock>`.
`org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
Matrix.`toBinaryBlocks()`
Obtain the matrix as a `JavaPairRDD<MatrixIndexes, MatrixBlock>`
Methods in org.apache.sysds.api.mlcontext with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixObject`
MLContextConversionUtil.`matrixBlockToMatrixObject(String variableName, MatrixBlock matrixBlock, MatrixMetadata matrixMetadata)`
Convert a `MatrixBlock` to a `MatrixObject`.
Method parameters in org.apache.sysds.api.mlcontext with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
MLContextConversionUtil.`binaryBlocksToMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> binaryBlocks, MatrixMetadata matrixMetadata)`
Convert a `JavaPairRDD<MatrixIndexes, MatrixBlock>` to a `MatrixBlock`
`static MatrixObject`
MLContextConversionUtil.`binaryBlocksToMatrixObject(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> binaryBlocks)`
Convert a `JavaPairRDD<MatrixIndexes, MatrixBlock>` to a `MatrixObject`.
`static MatrixObject`
MLContextConversionUtil.`binaryBlocksToMatrixObject(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> binaryBlocks, MatrixMetadata matrixMetadata)`
Convert a `JavaPairRDD<MatrixIndexes, MatrixBlock>` to a `MatrixObject`.
Constructor parameters in org.apache.sysds.api.mlcontext with type arguments of type MatrixBlock
Modifier
Constructor
Description
``
`Matrix(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> binaryBlocks, MatrixMetadata matrixMetadata)`
Create a Matrix, specifying the SystemDS binary-block matrix and its metadata.

## Uses of MatrixBlock in org.apache.sysds.hops.estim

Methods in org.apache.sysds.hops.estim that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MMNode.`getData()`
`MatrixBlock`
EstimatorDensityMap.DensityMap.`getMap()`
`MatrixBlock`
EstimatorLayeredGraph.LayeredGraph.`toMatrixBlock()`
Methods in org.apache.sysds.hops.estim that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`List<MatrixBlock>`
EstimatorLayeredGraph.LayeredGraph.`toMatrixBlockList()`
Methods in org.apache.sysds.hops.estim with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
EstimatorLayeredGraph.LayeredGraph.`buildNext(MatrixBlock mb)`
`EstimatorBitsetMM.BitsetMatrix`
EstimatorBitsetMM.`createBitset(MatrixBlock in)`
`double`
EstimatorBasicAvg.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorBasicAvg.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorBasicAvg.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorBasicWorst.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorBasicWorst.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorBasicWorst.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorBitsetMM.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorBitsetMM.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorBitsetMM.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorDensityMap.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorDensityMap.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorDensityMap.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorLayeredGraph.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorLayeredGraph.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorLayeredGraph.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorMatrixHistogram.`estim(MatrixBlock m1, SparsityEstimator.OpCode op)`
`double`
EstimatorMatrixHistogram.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorMatrixHistogram.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorRowWise.`estim(MatrixBlock m1, SparsityEstimator.OpCode op)`
`double`
EstimatorRowWise.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorRowWise.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorSample.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorSample.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorSample.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`double`
EstimatorSampleRa.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
`double`
EstimatorSampleRa.`estim(MatrixBlock m1, MatrixBlock m2)`
`double`
EstimatorSampleRa.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
`abstract double`
SparsityEstimator.`estim(MatrixBlock m, SparsityEstimator.OpCode op)`
Estimates the output sparsity for a given unary operation.
`abstract double`
SparsityEstimator.`estim(MatrixBlock m1, MatrixBlock m2)`
Estimates the output sparsity for a single matrix multiplication.
`abstract double`
SparsityEstimator.`estim(MatrixBlock m1, MatrixBlock m2, SparsityEstimator.OpCode op)`
Estimates the output sparsity for a given binary operation.
`static long`
EstimationUtils.`getSelfProductOutputNnz(MatrixBlock m1)`
This utility function computes the exact output nnz of a self matrix product without need to materialize the output.
`static long`
EstimationUtils.`getSparseProductOutputNnz(MatrixBlock m1, MatrixBlock m2)`
`void`
EstimatorMatrixHistogram.MatrixHistogram.`setData(MatrixBlock mb)`
Constructors in org.apache.sysds.hops.estim with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`BitsetMatrix1(MatrixBlock in)`
``
`BitsetMatrix2(MatrixBlock in)`
``
`DensityMap(MatrixBlock in, int b)`
``
`DensityMap(MatrixBlock map, int rlenOrig, int clenOrig, int b, boolean scaled)`
``
`LayeredGraph(MatrixBlock m, int r, int seed)`
``
`MatrixHistogram(MatrixBlock in, boolean useExcepts)`
``
`MMNode(MatrixBlock in)`
Constructor parameters in org.apache.sysds.hops.estim with type arguments of type MatrixBlock
Modifier
Constructor
Description
``
`LayeredGraph(List<MatrixBlock> chain, int r, int seed)`

## Uses of MatrixBlock in org.apache.sysds.hops.rewrite

Methods in org.apache.sysds.hops.rewrite with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
HopRewriteUtils.`copyLineNumbers(MatrixBlock mb, Hop tread)`
`static DataOp`
HopRewriteUtils.`createTransientRead(String name, MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.codegen

Fields in org.apache.sysds.runtime.codegen declared as MatrixBlock
Modifier and Type
Field
Description
`final MatrixBlock`
SpoofOperator.SideInput.`mdat`
Methods in org.apache.sysds.runtime.codegen that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k, long rix)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k, long rix)`
`abstract MatrixBlock`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, MatrixBlock out)`
`MatrixBlock`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, MatrixBlock out, int k)`
`MatrixBlock`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int numThreads)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, boolean allocTmp, boolean aggIncr, long rix)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
Methods in org.apache.sysds.runtime.codegen with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
SpoofMultiAggregate.`aggregatePartialResults(SpoofCellwise.AggOp[] aggOps, MatrixBlock c, MatrixBlock b)`
`static SpoofOperator.SideInput`
CodegenUtils.`createSideInput(MatrixBlock in)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k, long rix)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k, long rix)`
`abstract MatrixBlock`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, MatrixBlock out)`
`MatrixBlock`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, MatrixBlock out, int k)`
`MatrixBlock`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int numThreads)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, boolean allocTmp, boolean aggIncr, long rix)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
Method parameters in org.apache.sysds.runtime.codegen with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`ScalarObject`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, int k)`
`ScalarObject`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, int k, long rix)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`MatrixBlock`
SpoofCellwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k, long rix)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`MatrixBlock`
SpoofMultiAggregate.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k, long rix)`
`ScalarObject`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars)`
`ScalarObject`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, int k)`
`abstract MatrixBlock`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, MatrixBlock out)`
`MatrixBlock`
SpoofOperator.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalars, MatrixBlock out, int k)`
`ScalarObject`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects)`
`ScalarObject`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, int numThreads)`
`MatrixBlock`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofOuterProduct.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int numThreads)`
`ScalarObject`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, int k)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, boolean allocTmp, boolean aggIncr, long rix)`
`MatrixBlock`
SpoofRowwise.`execute(ArrayList<MatrixBlock> inputs, ArrayList<ScalarObject> scalarObjects, MatrixBlock out, int k)`
`static long`
SpoofOperator.`getTotalInputNnz(ArrayList<MatrixBlock> inputs)`
`static long`
SpoofOperator.`getTotalInputSize(ArrayList<MatrixBlock> inputs)`
`static boolean`
SpoofRowwise.`hasMatrixSideInput(ArrayList<MatrixBlock> inputs)`
Constructors in org.apache.sysds.runtime.codegen with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`SideInput(DenseBlock ddata, MatrixBlock mdata, int clength)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress

Subclasses of MatrixBlock in org.apache.sysds.runtime.compress
Modifier and Type
Class
Description
`class`
`CompressedMatrixBlock`
Methods in org.apache.sysds.runtime.compress that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CompressedMatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, AggregateBinaryOperator op)`
`MatrixBlock`
CompressedMatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, AggregateBinaryOperator op, boolean transposeLeft, boolean transposeRight)`
`MatrixBlock`
CompressedMatrixBlock.`aggregateUnaryOperations(AggregateUnaryOperator op, MatrixValue result, int blen, MatrixIndexes indexesIn, boolean inCP)`
`MatrixBlock`
CompressedMatrixBlock.`append(MatrixBlock[] that, MatrixBlock ret, boolean cbind)`
`MatrixBlock`
CompressedMatrixBlock.`binaryOperations(BinaryOperator op, MatrixValue thatValue, MatrixValue result)`
`MatrixBlock`
CompressedMatrixBlock.`binaryOperationsInPlace(BinaryOperator op, MatrixValue thatValue)`
`MatrixBlock`
CompressedMatrixBlock.`binaryOperationsLeft(BinaryOperator op, MatrixValue thatValue, MatrixValue result)`
`MatrixBlock`
CompressedMatrixBlock.`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype, int k)`
`MatrixBlock`
CompressedMatrixBlock.`colSum()`
`MatrixBlock`
CompressedMatrixBlock.`copyShallow(MatrixBlock that)`
`MatrixBlock`
CompressedMatrixBlock.`ctableSeqOperations(MatrixValue thatMatrix, double thatScalar, MatrixBlock resultBlock, boolean updateClen)`
`MatrixBlock`
CompressedMatrixBlock.`decompress()`
Decompress block into a MatrixBlock
`MatrixBlock`
CompressedMatrixBlock.`decompress(int k)`
Decompress block into a MatrixBlock
`MatrixBlock`
CompressedMatrixBlock.`extractTriangular(MatrixBlock ret, boolean lower, boolean diag, boolean values)`
`MatrixBlock`
CompressedMatrixBlock.`getCachedDecompressed()`
Get the cached decompressed matrix (if it exists otherwise null).
`MatrixBlock`
CompressedMatrixBlock.`getUncompressed()`
`MatrixBlock`
CompressedMatrixBlock.`getUncompressed(int k)`
`MatrixBlock`
CompressedMatrixBlock.`getUncompressed(String operation)`
`MatrixBlock`
CompressedMatrixBlock.`getUncompressed(String operation, int k)`
`static MatrixBlock`
CompressedMatrixBlock.`getUncompressed(MatrixValue mVal)`
`static MatrixBlock`
CompressedMatrixBlock.`getUncompressed(MatrixValue mVal, String message)`
`static MatrixBlock`
CompressedMatrixBlock.`getUncompressed(MatrixValue mVal, String message, int k)`
`MatrixBlock`
CompressedMatrixBlock.`groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, Operator op, int k)`
`MatrixBlock`
CompressedMatrixBlock.`leftIndexingOperations(ScalarObject scalar, int rl, int cl, MatrixBlock ret, MatrixObject.UpdateType update)`
`MatrixBlock`
CompressedMatrixBlock.`leftIndexingOperations(MatrixBlock rhsMatrix, int rl, int ru, int cl, int cu, MatrixBlock ret, MatrixObject.UpdateType update)`
`MatrixBlock`
CompressedMatrixBlock.`merge(MatrixBlock that, boolean appendOnly, boolean par, boolean deep)`
`MatrixBlock`
CompressedMatrixBlock.`quaternaryOperations(QuaternaryOperator qop, MatrixBlock um, MatrixBlock vm, MatrixBlock wm, MatrixBlock out, int k)`
`MatrixBlock`
CompressedMatrixBlock.`randOperationsInPlace(RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed)`
`MatrixBlock`
CompressedMatrixBlock.`randOperationsInPlace(RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed, int k)`
`MatrixBlock`
CompressedMatrixBlock.`removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
`MatrixBlock`
CompressedMatrixBlock.`reorgOperations(ReorgOperator op, MatrixValue ret, int startRow, int startColumn, int length)`
`MatrixBlock`
CompressedMatrixBlock.`replaceOperations(MatrixValue result, double pattern, double replacement, int k)`
`MatrixBlock`
CompressedMatrixBlock.`reshape(int rows, int cols, boolean byRow)`
`MatrixBlock`
CompressedMatrixBlock.`rexpandOperations(MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
`MatrixBlock`
CompressedMatrixBlock.`scalarOperations(ScalarOperator sop, MatrixValue result)`
`MatrixBlock`
CompressedMatrixBlock.`seqOperationsInPlace(double from, double to, double incr)`
`MatrixBlock`
CompressedMatrixBlock.`slice(int rl, int ru, int cl, int cu, boolean deep, MatrixBlock ret)`
`MatrixBlock`
CompressedMatrixBlock.`sortOperations(MatrixValue weights, MatrixBlock result, int k)`
`MatrixBlock`
CompressedMatrixBlock.`sparseToDense(int k)`
`MatrixBlock`
CompressedMatrixBlock.`ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret)`
`MatrixBlock`
CompressedMatrixBlock.`transpose(int k)`
`MatrixBlock`
CompressedMatrixBlock.`transposeSelfMatrixMultOperations(MatrixBlock out, MMTSJ.MMTSJType tstype, int k)`
`MatrixBlock`
CompressedMatrixBlock.`uaggouterchainOperations(MatrixBlock mbLeft, MatrixBlock mbRight, MatrixBlock mbOut, BinaryOperator bOp, AggregateUnaryOperator uaggOp)`
`MatrixBlock`
CompressedMatrixBlock.`unaryOperations(UnaryOperator op, MatrixValue result)`
`MatrixBlock`
CompressedMatrixBlock.`zeroOutOperations(MatrixValue result, IndexRange range)`
Methods in org.apache.sysds.runtime.compress that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`Future<MatrixBlock>`
CompressedMatrixBlock.`allocateBlockAsync()`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb)`
Default sequential compression with no parallelization
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings, ACostEstimate costEstimator)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings, CostEstimatorBuilder csb)`
The main method for compressing the input matrix.
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings, WTreeRoot root)`
The main method for compressing the input matrix.
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, ACostEstimate costEstimator)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CostEstimatorBuilder csb)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, InstructionTypeCounter ins)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, WTreeRoot root)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, CompressionSettingsBuilder customSettings)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, ACostEstimate costEstimator)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, CostEstimatorBuilder csb)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, InstructionTypeCounter ins)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, WTreeRoot root)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, ScalarObject sf, int k, WTreeRoot root)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, MatrixBlock sf, int k, WTreeRoot root)`
`SoftReference<MatrixBlock>`
CompressedMatrixBlock.`getSoftReferenceToDecompressed()`
Methods in org.apache.sysds.runtime.compress with parameters of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CompressedMatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, AggregateBinaryOperator op)`
`MatrixBlock`
CompressedMatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, AggregateBinaryOperator op, boolean transposeLeft, boolean transposeRight)`
`MatrixBlock`
CompressedMatrixBlock.`append(MatrixBlock[] that, MatrixBlock ret, boolean cbind)`
`void`
CompressedMatrixBlock.`appendRowToSparse(SparseBlock dest, MatrixBlock src, int i, int rowoffset, int coloffset, boolean deep)`
`MatrixBlock`
CompressedMatrixBlock.`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype, int k)`
`CmCovObject`
CompressedMatrixBlock.`cmOperations(CMOperator op, MatrixBlock weights)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb)`
Default sequential compression with no parallelization
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings, ACostEstimate costEstimator)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings, CostEstimatorBuilder csb)`
The main method for compressing the input matrix.
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CompressionSettingsBuilder compSettings, WTreeRoot root)`
The main method for compressing the input matrix.
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, ACostEstimate costEstimator)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, CostEstimatorBuilder csb)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, InstructionTypeCounter ins)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, int k, WTreeRoot root)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, CompressionSettingsBuilder customSettings)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, ACostEstimate costEstimator)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, CostEstimatorBuilder csb)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, InstructionTypeCounter ins)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, WTreeRoot root)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, ScalarObject sf, int k, WTreeRoot root)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,CompressionStatistics>`
CompressedMatrixBlockFactory.`compress(MatrixBlock mb, MatrixBlock sf, int k, WTreeRoot root)`
`void`
CompressedMatrixBlock.`copy(int rl, int ru, int cl, int cu, MatrixBlock src, boolean awareDestNZ)`
`MatrixBlock`
CompressedMatrixBlock.`copyShallow(MatrixBlock that)`
`CmCovObject`
CompressedMatrixBlock.`covOperations(COVOperator op, MatrixBlock that)`
`CmCovObject`
CompressedMatrixBlock.`covOperations(COVOperator op, MatrixBlock that, MatrixBlock weights)`
`void`
CompressedMatrixBlock.`ctableOperations(Operator op, double scalar, double scalar2, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
CompressedMatrixBlock.`ctableOperations(Operator op, double scalar, MatrixValue that, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
CompressedMatrixBlock.`ctableOperations(Operator op, MatrixIndexes ix1, double scalar, boolean left, int brlen, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
CompressedMatrixBlock.`ctableOperations(Operator op, MatrixValue that, double scalar, boolean ignoreZeros, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
CompressedMatrixBlock.`ctableOperations(Operator op, MatrixValue that, MatrixValue that2, CTableMap resultMap, MatrixBlock resultBlock)`
`MatrixBlock`
CompressedMatrixBlock.`ctableSeqOperations(MatrixValue thatMatrix, double thatScalar, MatrixBlock resultBlock, boolean updateClen)`
`MatrixBlock`
CompressedMatrixBlock.`extractTriangular(MatrixBlock ret, boolean lower, boolean diag, boolean values)`
`static CompressedMatrixBlock`
CompressedMatrixBlockFactory.`genUncompressedCompressedMatrixBlock(MatrixBlock mb)`
Generate a CompressedMatrixBlock Object that contains a single uncompressed matrix block column group.
`MatrixBlock`
CompressedMatrixBlock.`leftIndexingOperations(ScalarObject scalar, int rl, int cl, MatrixBlock ret, MatrixObject.UpdateType update)`
`MatrixBlock`
CompressedMatrixBlock.`leftIndexingOperations(MatrixBlock rhsMatrix, int rl, int ru, int cl, int cu, MatrixBlock ret, MatrixObject.UpdateType update)`
`MatrixBlock`
CompressedMatrixBlock.`merge(MatrixBlock that, boolean appendOnly, boolean par, boolean deep)`
`void`
CompressedMatrixBlock.`putInto(MatrixBlock target, int rowOffset, int colOffset, boolean sparseCopyShallow)`
`MatrixBlock`
CompressedMatrixBlock.`quaternaryOperations(QuaternaryOperator qop, MatrixBlock um, MatrixBlock vm, MatrixBlock wm, MatrixBlock out, int k)`
`MatrixBlock`
CompressedMatrixBlock.`removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
`MatrixBlock`
CompressedMatrixBlock.`rexpandOperations(MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
`MatrixBlock`
CompressedMatrixBlock.`slice(int rl, int ru, int cl, int cu, boolean deep, MatrixBlock ret)`
`MatrixBlock`
CompressedMatrixBlock.`sortOperations(MatrixValue weights, MatrixBlock result, int k)`
`MatrixBlock`
CompressedMatrixBlock.`ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret)`
`static boolean`
CompressedMatrixBlockFactory.`transposeHeuristics(int nGroups, MatrixBlock mb)`
`MatrixBlock`
CompressedMatrixBlock.`transposeSelfMatrixMultOperations(MatrixBlock out, MMTSJ.MMTSJType tstype, int k)`
`MatrixBlock`
CompressedMatrixBlock.`uaggouterchainOperations(MatrixBlock mbLeft, MatrixBlock mbRight, MatrixBlock mbOut, BinaryOperator bOp, AggregateUnaryOperator uaggOp)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.bitmap

Methods in org.apache.sysds.runtime.compress.bitmap with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static ABitmap`
BitmapEncoder.`extractBitmap(IColIndex colIndices, MatrixBlock rawBlock, boolean transposed, int estimatedNumberOfUniques, boolean sortedEntries)`
Generate uncompressed bitmaps for a set of columns in an uncompressed matrix block.
`static ABitmap`
BitmapEncoder.`extractBitmap(IColIndex colIndices, MatrixBlock rawBlock, boolean transposed, int estimatedNumberOfUniques, boolean sortedEntries, double[] scaleFactors)`
Generate quantization-fused uncompressed bitmaps for a set of columns in an uncompressed matrix block.
`static ABitmap`
BitmapEncoder.`extractBitmap(IColIndex colIndices, MatrixBlock rawBlock, int estimatedNumberOfUniques, CompressionSettings cs)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.colgroup

Methods in org.apache.sysds.runtime.compress.colgroup that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
ColGroupUncompressed.`getData()`
Access for superclass
Methods in org.apache.sysds.runtime.compress.colgroup with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
ColGroupUtils.`addMatrixToResult(MatrixBlock tmp, MatrixBlock result, IColIndex colIndexes, int rl, int ru)`
`static List<AColGroup>`
ColGroupFactory.`compressColGroups(MatrixBlock in, CompressedSizeInfo csi, CompressionSettings cs)`
The actual compression method, that handles the logic of compressing multiple columns together.
`static List<AColGroup>`
ColGroupFactory.`compressColGroups(MatrixBlock in, CompressedSizeInfo csi, CompressionSettings cs, int k)`
The actual compression method, that handles the logic of compressing multiple columns together.
`static List<AColGroup>`
ColGroupFactory.`compressColGroups(MatrixBlock in, CompressedSizeInfo csi, CompressionSettings cs, ACostEstimate ce, int k)`
`static void`
ColGroupUtils.`copyValuesColGroupMatrixBlocks(AColGroup lhs, AColGroup rhs, MatrixBlock tmpResult, MatrixBlock result)`
Copy values from tmpResult into correct positions of result (according to colIndexes in lhs and rhs)
`static AColGroup`
ColGroupUncompressed.`create(IColIndex colIndexes, MatrixBlock rawBlock, boolean transposed)`
Main constructor for Uncompressed ColGroup.
`static AColGroup`
ColGroupUncompressed.`create(MatrixBlock data)`
`static AColGroup`
ColGroupUncompressed.`create(MatrixBlock mb, IColIndex colIndexes)`
Create an Uncompressed Matrix Block, where the columns are offset by col indexes.
`static AColGroup`
ColGroupUncompressed.`createQuantized(IColIndex colIndexes, MatrixBlock rawBlock, boolean transposed, double[] scaleFactors)`
Main constructor for a quantization-fused uncompressed ColGroup.
`static AColGroup`
ColGroupUncompressed.`createQuantized(MatrixBlock mb, IColIndex colIndexes, double[] scaleFactors)`
Create ana quantization-fused uncompressed Matrix Block, where the columns are offset by col indexes.
`static double[]`
ColGroupUtils.`extractMostCommonValueInColumns(MatrixBlock mb)`
`abstract void`
APreAgg.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`void`
ColGroupDDC.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`void`
ColGroupDDCLZW.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`void`
ColGroupOLE.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`void`
ColGroupRLE.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`void`
ColGroupSDCSingleZeros.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`void`
ColGroupSDCZeros.`leftMMIdentityPreAggregateDense(MatrixBlock that, MatrixBlock ret, int rl, int ru, int cl, int cu)`
`abstract void`
AColGroup.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
Left side matrix multiplication with a column group that is transposed.
`final void`
AMorphingMMColGroup.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
`final void`
APreAgg.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
`void`
ColGroupConst.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
`void`
ColGroupEmpty.`leftMultByAColGroup(AColGroup lhs, MatrixBlock c, int nRows)`
`void`
ColGroupLinearFunctional.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
`void`
ColGroupUncompressed.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
`void`
ColGroupUncompressedArray.`leftMultByAColGroup(AColGroup lhs, MatrixBlock result, int nRows)`
`abstract void`
AColGroup.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
Left multiply with this column group.
`final void`
AMorphingMMColGroup.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`final void`
ASDCZero.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupConst.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupDDC.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupDDCLZW.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupDeltaDDC.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupEmpty.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupLinearFunctional.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupOLE.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupRLE.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupUncompressed.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
ColGroupUncompressedArray.`leftMultByMatrixNoPreAgg(MatrixBlock matrix, MatrixBlock result, int rl, int ru, int cl, int cu)`
`void`
APreAgg.`mmWithDictionary(MatrixBlock preAgg, MatrixBlock tmpRes, MatrixBlock ret, int k, int rl, int ru)`
`final void`
APreAgg.`preAggregate(MatrixBlock m, double[] preAgg, int rl, int ru)`
Pre aggregate a matrix block into a pre aggregate target (first step of left matrix multiplication)
`abstract void`
APreAgg.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
Pre aggregate a dense matrix block into a pre aggregate target (first step of left matrix multiplication)
`void`
ColGroupDDC.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
ColGroupDDCLZW.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
ColGroupDeltaDDC.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
ColGroupOLE.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
ColGroupRLE.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
ColGroupSDCSingleZeros.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
ColGroupSDCZeros.`preAggregateDense(MatrixBlock m, double[] preAgg, int rl, int ru, int cl, int cu)`
`void`
AColGroup.`rightDecompressingMult(MatrixBlock right, MatrixBlock ret, int rl, int ru, int nRows, int crl, int cru)`
Right side Matrix multiplication, iterating though this column group and adding to the ret
`void`
ColGroupDDC.`rightDecompressingMult(MatrixBlock right, MatrixBlock ret, int rl, int ru, int nRows, int crl, int cru)`
`void`
ColGroupDeltaDDC.`rightDecompressingMult(MatrixBlock right, MatrixBlock ret, int rl, int ru, int nRows, int crl, int cru)`
`final AColGroup`
AColGroup.`rightMultByMatrix(MatrixBlock right)`
Right matrix multiplication with this column group.
`abstract AColGroup`
AColGroup.`rightMultByMatrix(MatrixBlock right, IColIndex allCols, int k)`
Right matrix multiplication with this column group.
`final AColGroup`
ADictBasedColGroup.`rightMultByMatrix(MatrixBlock right, IColIndex allCols, int k)`
`AColGroup`
ColGroupEmpty.`rightMultByMatrix(MatrixBlock right, IColIndex allCols, int k)`
`AColGroup`
ColGroupLinearFunctional.`rightMultByMatrix(MatrixBlock right, IColIndex allCols, int k)`
`AColGroup`
ColGroupUncompressed.`rightMultByMatrix(MatrixBlock right, IColIndex allCols, int k)`
`AColGroup`
ColGroupUncompressedArray.`rightMultByMatrix(MatrixBlock right, IColIndex allCols, int k)`
`final void`
AColGroup.`selectionMultiply(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
Selection (left matrix multiply)
`void`
ColGroupDDC.`sparseSelection(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
`void`
ColGroupDDCLZW.`sparseSelection(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
`void`
ColGroupLinearFunctional.`sparseSelection(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
`void`
ColGroupSDCFOR.`sparseSelection(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
`void`
ColGroupSDCZeros.`sparseSelection(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
`void`
ColGroupUncompressed.`sparseSelection(MatrixBlock selection, ColGroupUtils.P[] points, MatrixBlock ret, int rl, int ru)`
`abstract void`
AColGroup.`tsmm(MatrixBlock ret, int nRows)`
Do a transposed self matrix multiplication on the left side t(x) %*% x.
`final void`
AColGroupCompressed.`tsmm(MatrixBlock ret, int nRows)`
`final void`
ColGroupUncompressed.`tsmm(MatrixBlock ret, int nRows)`
`void`
ColGroupUncompressedArray.`tsmm(MatrixBlock ret, int nRows)`
`abstract void`
AColGroup.`tsmmAColGroup(AColGroup other, MatrixBlock result)`
Matrix multiply with this other column group, but: 1.
`final void`
AMorphingMMColGroup.`tsmmAColGroup(AColGroup other, MatrixBlock result)`
`final void`
APreAgg.`tsmmAColGroup(AColGroup other, MatrixBlock result)`
`void`
ColGroupConst.`tsmmAColGroup(AColGroup other, MatrixBlock result)`
`void`
ColGroupEmpty.`tsmmAColGroup(AColGroup other, MatrixBlock result)`
`void`
ColGroupLinearFunctional.`tsmmAColGroup(AColGroup other, MatrixBlock result)`
`void`
ColGroupUncompressed.`tsmmAColGroup(AColGroup lhs, MatrixBlock result)`
`void`
ColGroupUncompressedArray.`tsmmAColGroup(AColGroup other, MatrixBlock result)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.colgroup.dictionary

Methods in org.apache.sysds.runtime.compress.colgroup.dictionary that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MatrixBlockDictionary.`getMatrixBlock()`
Methods in org.apache.sysds.runtime.compress.colgroup.dictionary with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlockDictionary`
MatrixBlockDictionary.`create(MatrixBlock mb)`
`static MatrixBlockDictionary`
MatrixBlockDictionary.`create(MatrixBlock mb, boolean check)`
`void`
ADictionary.`MMDict(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
Dictionary.`MMDict(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
IDictionary.`MMDict(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix multiplication of dictionaries note the left is this, and it is supposed to be treated as if it is transposed while it is not physically transposed.
`void`
MatrixBlockDictionary.`MMDict(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
ADictionary.`MMDictDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
Dictionary.`MMDictDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
IdentityDictionary.`MMDictDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
IDictionary.`MMDictDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix multiplication of dictionaries left side dense and transposed.
`void`
MatrixBlockDictionary.`MMDictDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`static void`
DictLibMatrixMult.`MMDicts(IDictionary left, IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix Multiply the two dictionaries, note that the left side is considered transposed but not allocated transposed making the multiplication a: t(left) %*% right
`void`
ADictionary.`MMDictScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
Dictionary.`MMDictScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
IDictionary.`MMDictScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
Matrix multiplication of dictionaries, note the left is this, and it is supposed to be treated as if it is transposed while it is not physically transposed.
`void`
MatrixBlockDictionary.`MMDictScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
ADictionary.`MMDictScalingDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
Dictionary.`MMDictScalingDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
IdentityDictionary.`MMDictScalingDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
IDictionary.`MMDictScalingDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
Matrix multiplication of dictionaries left side dense and transposed.
`void`
MatrixBlockDictionary.`MMDictScalingDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
ADictionary.`MMDictScalingSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
Dictionary.`MMDictScalingSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
IDictionary.`MMDictScalingSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
Matrix multiplication of dictionaries left side sparse and transposed right side is this.
`void`
MatrixBlockDictionary.`MMDictScalingSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result, int[] scaling)`
`void`
ADictionary.`MMDictSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
Dictionary.`MMDictSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
IDictionary.`MMDictSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix multiplication of dictionaries left side sparse and transposed right side is this.
`void`
MatrixBlockDictionary.`MMDictSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`static void`
DictLibMatrixMult.`MMDictsWithScaling(IDictionary left, IDictionary right, IColIndex leftRows, IColIndex rightColumns, MatrixBlock result, int[] counts)`
Matrix multiply with scaling (left side transposed)
`static double[]`
MatrixBlockDictionary.`sliceColumns(MatrixBlock mb, IntArrayList selectedColumns)`
`static void`
DictLibMatrixMult.`TSMMDictionaryWithScaling(IDictionary dict, int[] counts, IColIndex rows, IColIndex cols, MatrixBlock ret)`
Perform the full tsmm with the dictionary (allocating into the entire output matrix.)
`void`
ADictionary.`TSMMToUpperTriangle(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
Dictionary.`TSMMToUpperTriangle(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`static void`
DictLibMatrixMult.`TSMMToUpperTriangle(IDictionary left, IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Does two matrix multiplications in one go but only add to the upper triangle.
`void`
IDictionary.`TSMMToUpperTriangle(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix multiplication but allocate output in upper triangle and twice if on diagonal, note this is left
`void`
MatrixBlockDictionary.`TSMMToUpperTriangle(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
ADictionary.`TSMMToUpperTriangleDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
Dictionary.`TSMMToUpperTriangleDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
IDictionary.`TSMMToUpperTriangleDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix multiplication but allocate output in upper triangle and twice if on diagonal, note this is right
`void`
MatrixBlockDictionary.`TSMMToUpperTriangleDense(double[] left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
ADictionary.`TSMMToUpperTriangleDenseScaling(double[] left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
Dictionary.`TSMMToUpperTriangleDenseScaling(double[] left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
IDictionary.`TSMMToUpperTriangleDenseScaling(double[] left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
Matrix multiplication but allocate output in upper triangle and twice if on diagonal, note this is right
`void`
MatrixBlockDictionary.`TSMMToUpperTriangleDenseScaling(double[] left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
ADictionary.`TSMMToUpperTriangleScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
Dictionary.`TSMMToUpperTriangleScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`static void`
DictLibMatrixMult.`TSMMToUpperTriangleScaling(IDictionary left, IDictionary right, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
Does two matrix multiplications in one go but only add to the upper triangle with scaling.
`void`
IDictionary.`TSMMToUpperTriangleScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
Matrix multiplication but allocate output in upper triangle and twice if on diagonal, note this is left
`void`
MatrixBlockDictionary.`TSMMToUpperTriangleScaling(IDictionary right, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
ADictionary.`TSMMToUpperTriangleSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
Dictionary.`TSMMToUpperTriangleSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
IDictionary.`TSMMToUpperTriangleSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
Matrix multiplication but allocate output in upper triangle and twice if on diagonal, note this is right
`void`
MatrixBlockDictionary.`TSMMToUpperTriangleSparse(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, MatrixBlock result)`
`void`
ADictionary.`TSMMToUpperTriangleSparseScaling(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
Dictionary.`TSMMToUpperTriangleSparseScaling(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
IDictionary.`TSMMToUpperTriangleSparseScaling(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
Matrix multiplication but allocate output in upper triangle and twice if on diagonal, note this is right
`void`
MatrixBlockDictionary.`TSMMToUpperTriangleSparseScaling(SparseBlock left, IColIndex rowsLeft, IColIndex colsRight, int[] scale, MatrixBlock result)`
`void`
ADictionary.`TSMMWithScaling(int[] counts, IColIndex rows, IColIndex cols, MatrixBlock ret)`
`void`
Dictionary.`TSMMWithScaling(int[] counts, IColIndex rows, IColIndex cols, MatrixBlock ret)`
`void`
IDictionary.`TSMMWithScaling(int[] counts, IColIndex rows, IColIndex cols, MatrixBlock ret)`
Transpose self matrix multiplication with a scaling factor on each pair of values.
`void`
MatrixBlockDictionary.`TSMMWithScaling(int[] counts, IColIndex rows, IColIndex cols, MatrixBlock ret)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.colgroup.functional

Methods in org.apache.sysds.runtime.compress.colgroup.functional with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static double[]`
LinearRegression.`regressMatrixBlock(MatrixBlock rawBlock, IColIndex colIndexes, boolean transposed)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.colgroup.mapping

Methods in org.apache.sysds.runtime.compress.colgroup.mapping with parameters of type MatrixBlock
Modifier and Type
Method
Description
`final void`
AMapToData.`preAggregateDense(MatrixBlock m, double[] preAV, int rl, int ru, int cl, int cu)`
Pre aggregate a dense matrix m into pre, subject to only including a row segment and column segment.

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.colgroup.scheme

Methods in org.apache.sysds.runtime.compress.colgroup.scheme with parameters of type MatrixBlock
Modifier and Type
Method
Description
`final AColGroup`
ACLAScheme.`encode(MatrixBlock data)`
`final AColGroup`
ACLAScheme.`encode(MatrixBlock data, IColIndex columns)`
`CompressedMatrixBlock`
CompressionScheme.`encode(MatrixBlock mb)`
Encode the given matrix block, it is assumed that the given MatrixBlock already fit the current scheme.
`CompressedMatrixBlock`
CompressionScheme.`encode(MatrixBlock mb, int k)`
Encode the given matrix block, it is assumed that the given MatrixBlock already fit the current scheme.
`AColGroup`
ICLAScheme.`encode(MatrixBlock data)`
Encode the given matrix block into the scheme provided in the instance.
`AColGroup`
ICLAScheme.`encode(MatrixBlock data, IColIndex columns)`
Encode a given matrix block into the scheme provided in the instance but overwrite what columns to use.
`final AColGroup`
ACLAScheme.`encodeT(MatrixBlock data)`
`final AColGroup`
ACLAScheme.`encodeT(MatrixBlock data, IColIndex columns)`
`AColGroup`
ICLAScheme.`encodeT(MatrixBlock data)`
Encode the given matrix block into the scheme provided in the instance, the input data is transposed The method is unsafe in the sense that if the encoding scheme does not fit, there is no guarantee that an error is thrown.
`AColGroup`
ICLAScheme.`encodeT(MatrixBlock data, IColIndex columns)`
Encode a given matrix block into the scheme provided in the instance but overwrite what columns to use.
`final ICLAScheme`
ACLAScheme.`update(MatrixBlock data)`
`final ICLAScheme`
ACLAScheme.`update(MatrixBlock data, IColIndex columns)`
`CompressionScheme`
CompressionScheme.`update(MatrixBlock mb)`
Update the encodings contained to also enable compression of the given mb.
`CompressionScheme`
CompressionScheme.`update(MatrixBlock mb, int k)`
Update the encodings contained to also enable compression of the given mb.
`ICLAScheme`
ICLAScheme.`update(MatrixBlock data)`
Update the encoding scheme to enable compression of the given data.
`ICLAScheme`
ICLAScheme.`update(MatrixBlock data, IColIndex columns)`
Update the encoding scheme to enable compression of the given data.
`final Pair<ICLAScheme,AColGroup>`
ACLAScheme.`updateAndEncode(MatrixBlock data)`
`final Pair<ICLAScheme,AColGroup>`
ACLAScheme.`updateAndEncode(MatrixBlock data, IColIndex columns)`
`CompressedMatrixBlock`
CompressionScheme.`updateAndEncode(MatrixBlock mb)`
`CompressedMatrixBlock`
CompressionScheme.`updateAndEncode(MatrixBlock mb, int k)`
`Pair<ICLAScheme,AColGroup>`
ICLAScheme.`updateAndEncode(MatrixBlock data)`
Update and encode the given block in a single pass.
`Pair<ICLAScheme,AColGroup>`
ICLAScheme.`updateAndEncode(MatrixBlock data, IColIndex columns)`
Try to update and encode in a single pass over the data.
`final Pair<ICLAScheme,AColGroup>`
ACLAScheme.`updateAndEncodeT(MatrixBlock data)`
`final Pair<ICLAScheme,AColGroup>`
ACLAScheme.`updateAndEncodeT(MatrixBlock data, IColIndex columns)`
`Pair<ICLAScheme,AColGroup>`
ICLAScheme.`updateAndEncodeT(MatrixBlock data)`
Update and encode the given block in a single pass.
`Pair<ICLAScheme,AColGroup>`
ICLAScheme.`updateAndEncodeT(MatrixBlock data, IColIndex columns)`
Try to update and encode in a single pass over the data.
`final ICLAScheme`
ACLAScheme.`updateT(MatrixBlock data)`
`final ICLAScheme`
ACLAScheme.`updateT(MatrixBlock data, IColIndex columns)`
`ICLAScheme`
ICLAScheme.`updateT(MatrixBlock data)`
Update the encoding scheme to enable compression of the given data.
`ICLAScheme`
ICLAScheme.`updateT(MatrixBlock data, IColIndex columns)`
Update the encoding scheme to enable compression of the given data.

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.cost

Methods in org.apache.sysds.runtime.compress.cost with parameters of type MatrixBlock
Modifier and Type
Method
Description
`abstract double`
ACostEstimate.`getCost(MatrixBlock mb)`
Get the cost of a matrix block.
`double`
ComputationCostEstimator.`getCost(MatrixBlock mb)`
`double`
DistinctCostEstimator.`getCost(MatrixBlock mb)`
`double`
HybridCostEstimator.`getCost(MatrixBlock mb)`
`double`
MemoryCostEstimator.`getCost(MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.estim

Methods in org.apache.sysds.runtime.compress.estim with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static AComEst`
ComEstFactory.`createEstimator(MatrixBlock data, CompressionSettings cs, int k)`
Create an estimator for the input data with the given settings and parallelization degree.
`static AComEst`
ComEstFactory.`createEstimator(MatrixBlock data, CompressionSettings cs, int sampleSize, int k)`
Create an estimator for the input data with the given settings and parallelization degree.
Constructors in org.apache.sysds.runtime.compress.estim with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`ComEstExact(MatrixBlock data, CompressionSettings compSettings)`
``
`ComEstSample(MatrixBlock data, CompressionSettings cs, int sampleSize, int k)`
CompressedSizeEstimatorSample, samples from the input data and estimates the size of the compressed matrix.
``
`ComEstSample(MatrixBlock sample, CompressionSettings cs, MatrixBlock full, int k)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.estim.encoding

Methods in org.apache.sysds.runtime.compress.estim.encoding with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static IEncode`
EncodingFactory.`createFromMatrixBlock(MatrixBlock m, boolean transposed, int rowCol)`
Create encoding of a single specific column inside the matrix input.
`static IEncode`
EncodingFactory.`createFromMatrixBlock(MatrixBlock m, boolean transposed, int rowCol, double[] scaleFactors)`
Create encoding of a single specific column inside the matrix input.
`static IEncode`
EncodingFactory.`createFromMatrixBlock(MatrixBlock m, boolean transposed, IColIndex rowCols)`
Encode a list of columns together from the input matrix, as if it is cocoded.
`static IEncode`
EncodingFactory.`createFromMatrixBlock(MatrixBlock m, boolean transposed, IColIndex rowCols, double[] scaleFactors)`
`static IEncode`
EncodingFactory.`createFromMatrixBlockDelta(MatrixBlock m, boolean transposed, IColIndex rowCols)`
Encode a full delta representation of the matrix input taking all rows into account.
`static IEncode`
EncodingFactory.`createFromMatrixBlockDelta(MatrixBlock m, boolean transposed, IColIndex rowCols, int sampleSize)`
Encode a delta representation of the matrix input taking the first "sampleSize" rows into account.

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.io

Fields in org.apache.sysds.runtime.compress.io declared as MatrixBlock
Modifier and Type
Field
Description
`MatrixBlock`
CompressedWriteBlock.`mb`
Methods in org.apache.sysds.runtime.compress.io that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CompressUnwrap.`call(CompressedWriteBlock arg0)`
`MatrixBlock`
CompressedWriteBlock.`get()`
`static MatrixBlock`
ReaderCompressed.`readCompressedMatrixFromHDFS(String fname, long rlen, long clen, int blen)`
`MatrixBlock`
ReaderCompressed.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderCompressed.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
Methods in org.apache.sysds.runtime.compress.io that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
ReaderSparkCompressed.`getRDD(org.apache.spark.api.java.JavaSparkContext sc, String fileName)`
Methods in org.apache.sysds.runtime.compress.io with parameters of type MatrixBlock
Modifier and Type
Method
Description
`CompressedWriteBlock`
CompressWrap.`call(MatrixBlock arg0)`
`static void`
WriterCompressed.`writeCompressedMatrixToHDFS(MatrixBlock src, String fname)`
`static void`
WriterCompressed.`writeCompressedMatrixToHDFS(MatrixBlock src, String fname, int blen)`
`static void`
WriterCompressed.`writeCompressedMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`void`
WriterCompressed.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
Method parameters in org.apache.sysds.runtime.compress.io with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static void`
WriterCompressed.`writeRDDToHDFS(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> src, String path)`
`static void`
WriterCompressed.`writeRDDToHDFS(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> src, String path, int blen, DataCharacteristics mc)`
Constructors in org.apache.sysds.runtime.compress.io with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`CompressedWriteBlock(MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.lib

Methods in org.apache.sysds.runtime.compress.lib that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
CLALibAggTernaryOp.`agg(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, AggregateTernaryOperator op, boolean inCP)`
`static MatrixBlock`
CLALibCompAgg.`aggregateUnary(CompressedMatrixBlock inputMatrix, MatrixBlock result, AggregateUnaryOperator op, int blen, MatrixIndexes indexesIn, boolean inCP)`
`static MatrixBlock`
CLALibBinaryCellOp.`binaryOperationsLeft(BinaryOperator op, CompressedMatrixBlock m1, MatrixBlock that)`
`static MatrixBlock`
CLALibBinaryCellOp.`binaryOperationsRight(BinaryOperator op, CompressedMatrixBlock m1, MatrixBlock that)`
`static MatrixBlock`
CLALibCBind.`cbind(MatrixBlock left, MatrixBlock[] right, int k)`
`static MatrixBlock`
CLALibCBind.`cbind(MatrixBlock left, MatrixBlock right, int k)`
`static MatrixBlock`
CLALibStack.`combine(Map<MatrixIndexes,MatrixBlock> m, Map<Integer,List<IDictionary>> d, int k)`
Combine the map of index matrix blocks into a single MatrixBlock.
`static MatrixBlock`
CLALibStack.`combine(Map<MatrixIndexes,MatrixBlock> m, Map<Integer,List<IDictionary>> d, int rlen, int clen, int blen, int k)`
Alternative read, when dimensions are known.
`static MatrixBlock`
CLALibDecompress.`decompress(CompressedMatrixBlock cmb, int k)`
`static MatrixBlock`
CLALibLeftMultBy.`leftMultByMatrix(CompressedMatrixBlock right, MatrixBlock left, MatrixBlock ret, int k)`
Left multiplication with two CompressedMatrixBlock following the equation: ret = left %*% right
`static MatrixBlock`
CLALibLeftMultBy.`leftMultByMatrixTransposed(CompressedMatrixBlock right, CompressedMatrixBlock left, MatrixBlock ret, int k)`
Left multiplication with two CompressedMatrixBlock following the equation:
`static MatrixBlock`
CLALibLeftMultBy.`leftMultByMatrixTransposed(CompressedMatrixBlock right, MatrixBlock left, MatrixBlock ret, int k)`
Left multiplication with a CompressedMatrixBlock on the right following the equation:
`static MatrixBlock`
CLALibTSMM.`leftMultByTransposeSelf(CompressedMatrixBlock cmb, int k)`
`static MatrixBlock`
CLALibTSMM.`leftMultByTransposeSelf(CompressedMatrixBlock cmb, MatrixBlock ret, int k)`
Self left Matrix multiplication (tsmm) t(x) %*% x
`static MatrixBlock`
CLALibSelectionMult.`leftSelection(CompressedMatrixBlock right, MatrixBlock left, MatrixBlock ret, int k)`
Left selection where the left matrix is sparse with a max 1 non zero per row and that non zero is a 1.
`static MatrixBlock`
CLALibMatrixMult.`matrixMultiply(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
`static MatrixBlock`
CLALibMatrixMult.`matrixMultiply(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k, boolean transposeLeft, boolean transposeRight)`
`static MatrixBlock`
CLALibMerge.`merge(MatrixBlock a, MatrixBlock b, boolean appendOnly, boolean par, boolean deep)`
Merge b into a, if possible otherwise
`static MatrixBlock`
CLALibMMChain.`mmChain(CompressedMatrixBlock x, MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype, int k)`
Support compressed MM chain operation to fuse the following cases :
`static MatrixBlock`
CLALibReorg.`reorg(CompressedMatrixBlock cmb, ReorgOperator op, MatrixBlock ret, int startRow, int startColumn, int length)`
`static MatrixBlock`
CLALibReplace.`replace(CompressedMatrixBlock in, MatrixBlock out, double pattern, double replacement, int k)`
`static MatrixBlock`
CLALibReshape.`reshape(CompressedMatrixBlock in, int rows, int cols, boolean rowwise)`
`static MatrixBlock`
CLALibReshape.`reshape(CompressedMatrixBlock in, int rows, int cols, boolean rowwise, int k)`
`static MatrixBlock`
CLALibRexpand.`rexpand(int seqHeight, MatrixBlock A)`
`static MatrixBlock`
CLALibRexpand.`rexpand(int seqHeight, MatrixBlock A, int nColOut)`
`static MatrixBlock`
CLALibRexpand.`rexpand(int seqHeight, MatrixBlock A, int nColOut, int k)`
`static MatrixBlock`
CLALibRexpand.`rexpand(CompressedMatrixBlock in, MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
`static MatrixBlock`
CLALibRightMultBy.`rightMultByMatrix(CompressedMatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
`static MatrixBlock`
CLALibRightMultBy.`rightMultByMatrix(CompressedMatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k, boolean allowOverlap)`
`static MatrixBlock`
CLALibRemoveEmpty.`rmempty(CompressedMatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
CP rmempty operation (single input, single output matrix)
`static MatrixBlock`
CLALibScalar.`scalarOperations(ScalarOperator sop, CompressedMatrixBlock m1, MatrixValue result)`
`static MatrixBlock`
CLALibSlice.`slice(CompressedMatrixBlock cmb, int rl, int ru, int cl, int cu, boolean deep)`
`static MatrixBlock`
CLALibSlice.`sliceRowsCompressed(CompressedMatrixBlock cmb, int rl, int ru)`
`static MatrixBlock`
CLALibSort.`sort(CompressedMatrixBlock mb, SortIndex fn)`
Sort (order) a compressed matrix in place of the `order` built-in, while keeping the result compressed.
`static MatrixBlock`
CLALibSort.`sort(CompressedMatrixBlock mb, MatrixValue weights, MatrixBlock result, int k)`
Compute the sorted value/weight table used by the quantile/median/IQM operations (the `sort` / qsort lop), exploiting compression to sort the few distinct values instead of all rows.
`static MatrixBlock`
CLALibTernaryOp.`ternaryOperations(TernaryOperator op, MatrixBlock m1, MatrixBlock m2, MatrixBlock m3)`
`static MatrixBlock`
CLALibUnary.`unaryOperations(CompressedMatrixBlock m, UnaryOperator op, MatrixValue result)`
Methods in org.apache.sysds.runtime.compress.lib that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,FrameBlock>`
CLALibBinCompress.`binCompress(CacheBlock<?> X, MatrixBlock d, int k)`
`static List<MatrixBlock>`
CLALibSlice.`sliceBlocks(CompressedMatrixBlock cmb, int blen, int k)`
Slice blocks of compressed matrices from the compressed representation.
Methods in org.apache.sysds.runtime.compress.lib with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
CLALibAggTernaryOp.`agg(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, AggregateTernaryOperator op, boolean inCP)`
`static MatrixBlock`
CLALibCompAgg.`aggregateUnary(CompressedMatrixBlock inputMatrix, MatrixBlock result, AggregateUnaryOperator op, int blen, MatrixIndexes indexesIn, boolean inCP)`
`static MatrixBlock`
CLALibBinaryCellOp.`binaryOperationsLeft(BinaryOperator op, CompressedMatrixBlock m1, MatrixBlock that)`
`static MatrixBlock`
CLALibBinaryCellOp.`binaryOperationsRight(BinaryOperator op, CompressedMatrixBlock m1, MatrixBlock that)`
`static org.apache.commons.lang3.tuple.Pair<MatrixBlock,FrameBlock>`
CLALibBinCompress.`binCompress(CacheBlock<?> X, MatrixBlock d, int k)`
`static MatrixBlock`
CLALibCBind.`cbind(MatrixBlock left, MatrixBlock[] right, int k)`
`static MatrixBlock`
CLALibCBind.`cbind(MatrixBlock left, MatrixBlock right, int k)`
`static void`
CLALibDecompress.`decompressDense(MatrixBlock ret, List<AColGroup> groups, double[] constV, double eps, int k, boolean overlapping)`
`static void`
CLALibDecompress.`decompressTo(CompressedMatrixBlock cmb, MatrixBlock ret, int rowOffset, int colOffset, int k, boolean countNNz)`
`static void`
CLALibDecompress.`decompressTo(CompressedMatrixBlock cmb, MatrixBlock ret, int rowOffset, int colOffset, int k, boolean countNNz, boolean reset)`
`static boolean`
CLALibSelectionMult.`isSelectionMatrix(MatrixBlock mb)`
Analyze if the given matrix is a selection matrix if on the left side of a matrix multiplication.
`static MatrixBlock`
CLALibLeftMultBy.`leftMultByMatrix(CompressedMatrixBlock right, MatrixBlock left, MatrixBlock ret, int k)`
Left multiplication with two CompressedMatrixBlock following the equation: ret = left %*% right
`static MatrixBlock`
CLALibLeftMultBy.`leftMultByMatrixTransposed(CompressedMatrixBlock right, CompressedMatrixBlock left, MatrixBlock ret, int k)`
Left multiplication with two CompressedMatrixBlock following the equation:
`static MatrixBlock`
CLALibLeftMultBy.`leftMultByMatrixTransposed(CompressedMatrixBlock right, MatrixBlock left, MatrixBlock ret, int k)`
Left multiplication with a CompressedMatrixBlock on the right following the equation:
`static MatrixBlock`
CLALibTSMM.`leftMultByTransposeSelf(CompressedMatrixBlock cmb, MatrixBlock ret, int k)`
Self left Matrix multiplication (tsmm) t(x) %*% x
`static MatrixBlock`
CLALibSelectionMult.`leftSelection(CompressedMatrixBlock right, MatrixBlock left, MatrixBlock ret, int k)`
Left selection where the left matrix is sparse with a max 1 non zero per row and that non zero is a 1.
`static MatrixBlock`
CLALibMatrixMult.`matrixMultiply(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
`static MatrixBlock`
CLALibMatrixMult.`matrixMultiply(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k, boolean transposeLeft, boolean transposeRight)`
`static MatrixBlock`
CLALibMerge.`merge(MatrixBlock a, MatrixBlock b, boolean appendOnly, boolean par, boolean deep)`
Merge b into a, if possible otherwise
`static MatrixBlock`
CLALibMMChain.`mmChain(CompressedMatrixBlock x, MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype, int k)`
Support compressed MM chain operation to fuse the following cases :
`static MatrixBlock`
CLALibReorg.`reorg(CompressedMatrixBlock cmb, ReorgOperator op, MatrixBlock ret, int startRow, int startColumn, int length)`
`static MatrixBlock`
CLALibReplace.`replace(CompressedMatrixBlock in, MatrixBlock out, double pattern, double replacement, int k)`
`static MatrixBlock`
CLALibRexpand.`rexpand(int seqHeight, MatrixBlock A)`
`static MatrixBlock`
CLALibRexpand.`rexpand(int seqHeight, MatrixBlock A, int nColOut)`
`static MatrixBlock`
CLALibRexpand.`rexpand(int seqHeight, MatrixBlock A, int nColOut, int k)`
`static MatrixBlock`
CLALibRexpand.`rexpand(CompressedMatrixBlock in, MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
`static MatrixBlock`
CLALibRightMultBy.`rightMultByMatrix(CompressedMatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
`static MatrixBlock`
CLALibRightMultBy.`rightMultByMatrix(CompressedMatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k, boolean allowOverlap)`
`static MatrixBlock`
CLALibRemoveEmpty.`rmempty(CompressedMatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
CP rmempty operation (single input, single output matrix)
`static double[]`
CLALibLeftMultBy.`rowSum(MatrixBlock mb, int rl, int ru, int cl, int cu)`
`static MatrixBlock`
CLALibSort.`sort(CompressedMatrixBlock mb, MatrixValue weights, MatrixBlock result, int k)`
Compute the sorted value/weight table used by the quantile/median/IQM operations (the `sort` / qsort lop), exploiting compression to sort the few distinct values instead of all rows.
`static MatrixBlock`
CLALibTernaryOp.`ternaryOperations(TernaryOperator op, MatrixBlock m1, MatrixBlock m2, MatrixBlock m3)`
Method parameters in org.apache.sysds.runtime.compress.lib with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
CLALibStack.`combine(Map<MatrixIndexes,MatrixBlock> m, Map<Integer,List<IDictionary>> d, int k)`
Combine the map of index matrix blocks into a single MatrixBlock.
`static MatrixBlock`
CLALibStack.`combine(Map<MatrixIndexes,MatrixBlock> m, Map<Integer,List<IDictionary>> d, int rlen, int clen, int blen, int k)`
Alternative read, when dimensions are known.

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.plan

Methods in org.apache.sysds.runtime.compress.plan with parameters of type MatrixBlock
Modifier and Type
Method
Description
`CompressedMatrixBlock`
IPlanEncode.`encode(MatrixBlock in)`
Encode a given matrix block subject to the plan given, while erroring out in case of breaking compression
`CompressedMatrixBlock`
NaivePlanEncode.`encode(MatrixBlock in)`
`void`
IPlanEncode.`expandPlan(MatrixBlock in)`
Given a block expand the plan to enable encoding of the given block.
`void`
NaivePlanEncode.`expandPlan(MatrixBlock in)`
`void`
NaivePlanEncode.`expandPlanMultiThread(MatrixBlock in)`
`void`
NaivePlanEncode.`expandPlanSingleThread(MatrixBlock in)`

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.readers

Methods in org.apache.sysds.runtime.compress.readers with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static ReaderColumnSelection`
ReaderColumnSelection.`createDeltaReader(MatrixBlock rawBlock, IColIndex colIndices, boolean transposed)`
Create a reader of the matrix block that computes delta values (current row - previous row) on-the-fly.
`static ReaderColumnSelection`
ReaderColumnSelection.`createDeltaReader(MatrixBlock rawBlock, IColIndex colIndices, boolean transposed, int rl, int ru)`
Create a reader of the matrix block that computes delta values (current row - previous row) on-the-fly.
`static ReaderColumnSelection`
ReaderColumnSelection.`createQuantizedReader(MatrixBlock rawBlock, IColIndex colIndices, boolean transposed, double[] scaleFactors)`
Create a reader of the matrix block that directly reads quantized values using scale factors.
`static ReaderColumnSelection`
ReaderColumnSelection.`createQuantizedReader(MatrixBlock rawBlock, IColIndex colIndices, boolean transposed, int rl, int ru, double[] scaleFactors)`
Create a reader of the matrix block that directly reads quantized values using scale factors.
`static ReaderColumnSelection`
ReaderColumnSelection.`createReader(MatrixBlock rawBlock, IColIndex colIndices, boolean transposed)`
Create a reader of the matrix block that is able to iterate though all the rows and return as dense double arrays.
`static ReaderColumnSelection`
ReaderColumnSelection.`createReader(MatrixBlock rawBlock, IColIndex colIndices, boolean transposed, int rl, int ru)`
Create a reader of the matrix block that is able to iterate though all the rows and return as dense double arrays.

## Uses of MatrixBlock in org.apache.sysds.runtime.compress.utils

Methods in org.apache.sysds.runtime.compress.utils that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CompressRDDClean.`call(MatrixBlock mb)`
`static MatrixBlock`
Util.`extractValues(double[] v, IColIndex colIndexes)`
`static MatrixBlock`
Util.`matrixBlockFromDenseArray(double[] values, int nCol)`
`static MatrixBlock`
Util.`matrixBlockFromDenseArray(double[] values, int nCol, boolean check)`
Methods in org.apache.sysds.runtime.compress.utils with parameters of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CompressRDDClean.`call(MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.caching

Methods in org.apache.sysds.runtime.controlprogram.caching that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MatrixObject.`readMatrixPartition(IndexRange pred)`
NOTE: for reading matrix partitions, we could cache (in its real sense) the read block with soft references (no need for eviction, as partitioning only applied for read-only matrices).
Methods in org.apache.sysds.runtime.controlprogram.caching with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
MatrixObject.`setInMemoryPartition(MatrixBlock block)`
Constructors in org.apache.sysds.runtime.controlprogram.caching with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`MatrixObject(Types.ValueType vt, String file, MetaData mtd, MatrixBlock data)`
Constructor that takes the value type, HDFS filename and associated metadata and a MatrixBlock used for creation after serialization

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.context

Methods in org.apache.sysds.runtime.controlprogram.context that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MatrixObjectFuture.`acquireRead()`
`MatrixBlock`
ExecutionContext.`getMatrixInput(String varName)`
Pins a matrix variable into memory and returns the internal matrix block.
`MatrixBlock`
ExecutionContext.`getMatrixInput(CPOperand input)`
`static MatrixBlock`
SparkExecutionContext.`toMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> rdd, int rlen, int clen, int blen, long nnz)`
Utility method for creating a single matrix block out of a binary block RDD.
`static MatrixBlock`
SparkExecutionContext.`toMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixCell> rdd, int rlen, int clen, long nnz)`
Utility method for creating a single matrix block out of a binary cell RDD.
`static MatrixBlock`
SparkExecutionContext.`toMatrixBlock(RDDObject rdd, int rlen, int clen, int blen, long nnz)`
This method is a generic abstraction for calls from the buffer pool.
`static MatrixBlock`
SparkExecutionContext.`toMatrixBlock(RDDObject rdd, int rlen, int clen, long nnz)`
Methods in org.apache.sysds.runtime.controlprogram.context that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkExecutionContext.`getBinaryMatrixBlockRDDHandleForVariable(String varname)`
Spark instructions should call this for all matrix inputs except broadcast variables.
`org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkExecutionContext.`getBinaryMatrixBlockRDDHandleForVariable(String varname, int numParts, boolean inclEmpty)`
`PartitionedBroadcast<MatrixBlock>`
SparkExecutionContext.`getBroadcastForMatrixObject(MatrixObject mo)`
`PartitionedBroadcast<MatrixBlock>`
SparkExecutionContext.`getBroadcastForVariable(String varname)`
`List<MatrixBlock>`
ExecutionContext.`getMatrixInputs(CPOperand[] inputs)`
`List<MatrixBlock>`
ExecutionContext.`getMatrixInputs(CPOperand[] inputs, boolean includeList)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkExecutionContext.`toMatrixJavaPairRDD(org.apache.spark.api.java.JavaSparkContext sc, MatrixBlock src, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkExecutionContext.`toMatrixJavaPairRDD(org.apache.spark.api.java.JavaSparkContext sc, MatrixBlock src, int blen, int numParts, boolean inclEmpty)`
`static PartitionedBlock<MatrixBlock>`
SparkExecutionContext.`toPartitionedMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> rdd, int rlen, int clen, int blen, long nnz)`
Methods in org.apache.sysds.runtime.controlprogram.context with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixObject`
ExecutionContext.`createMatrixObject(MatrixBlock mb)`
`void`
ExecutionContext.`setMatrixOutput(String varName, MatrixBlock outputData)`
`void`
ExecutionContext.`setMatrixOutput(String varName, MatrixBlock outputData, MatrixObject.UpdateType flag)`
`void`
ExecutionContext.`setMatrixOutputAndLineage(String varName, MatrixBlock outputData, LineageItem li)`
`void`
ExecutionContext.`setMatrixOutputAndLineage(CPOperand var, MatrixBlock outputData, LineageItem li)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkExecutionContext.`toMatrixJavaPairRDD(org.apache.spark.api.java.JavaSparkContext sc, MatrixBlock src, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkExecutionContext.`toMatrixJavaPairRDD(org.apache.spark.api.java.JavaSparkContext sc, MatrixBlock src, int blen, int numParts, boolean inclEmpty)`
Method parameters in org.apache.sysds.runtime.controlprogram.context with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`void`
ExecutionContext.`setMatrixOutput(String varName, Future<MatrixBlock> fmb)`
`void`
ExecutionContext.`setMatrixOutputAndLineage(String varName, Future<MatrixBlock> fmb, LineageItem li)`
`static MatrixBlock`
SparkExecutionContext.`toMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> rdd, int rlen, int clen, int blen, long nnz)`
Utility method for creating a single matrix block out of a binary block RDD.
`static PartitionedBlock<MatrixBlock>`
SparkExecutionContext.`toPartitionedMatrixBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> rdd, int rlen, int clen, int blen, long nnz)`
Constructor parameters in org.apache.sysds.runtime.controlprogram.context with type arguments of type MatrixBlock
Modifier
Constructor
Description
``
`MatrixObjectFuture(Types.ValueType vt, String file, Future<MatrixBlock> fmb)`
``
`MatrixObjectFuture(MatrixObject mo, Future<MatrixBlock> fmb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.federated

Methods in org.apache.sysds.runtime.controlprogram.federated that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
FederationUtils.`aggAdd(Future<FederatedResponse>[] ffr)`
`static MatrixBlock`
FederationUtils.`aggMatrix(AggregateUnaryOperator aop, Future<FederatedResponse>[] ffr, Future<FederatedResponse>[] meanFfr, FederationMap map)`
`static MatrixBlock`
FederationUtils.`aggMatrix(AggregateUnaryOperator aop, Future<FederatedResponse>[] ffr, FederationMap map)`
`static MatrixBlock`
FederationUtils.`aggMean(Future<FederatedResponse>[] ffr, FederationMap map)`
`static MatrixBlock`
FederationUtils.`aggMinMax(Future<FederatedResponse>[] ffr, boolean isMin, boolean isScalar, Optional<FTypes.FType> fedType)`
`static MatrixBlock`
FederationUtils.`aggMinMaxIndex(Future<FederatedResponse>[] ffr, boolean isMin, FederationMap map)`
`static MatrixBlock`
FederationUtils.`aggProd(Future<FederatedResponse>[] ffr, FederationMap fedMap, AggregateUnaryOperator aop)`
`static MatrixBlock`
FederationUtils.`aggregateResponses(List<org.apache.commons.lang3.tuple.Pair<FederatedRange,Future<FederatedResponse>>> readResponses)`
Aggregate partially aggregated data from federated workers by adding values with the same index in different federated locations.
`static MatrixBlock`
FederationUtils.`aggVar(Future<FederatedResponse>[] ffr, Future<FederatedResponse>[] meanFfr, FederationMap map, boolean isRowAggregate, boolean isScalar)`
`static MatrixBlock`
FederationUtils.`bind(Future<FederatedResponse>[] ffr, boolean cbind)`
`static MatrixBlock`
FederationUtils.`bindResponses(List<org.apache.commons.lang3.tuple.Pair<FederatedRange,Future<FederatedResponse>>> readResponses, long[] dims)`
Bind data from federated workers based on non-overlapping federated ranges.
`static MatrixBlock[]`
FederationUtils.`getResults(Future<FederatedResponse>[] ffr)`

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.paramserv

Methods in org.apache.sysds.runtime.controlprogram.paramserv that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
ParamservUtils.`cbindMatrix(MatrixBlock left, MatrixBlock right)`
`static MatrixBlock`
ParamservUtils.`generatePermutation(int numEntries, long seed)`
Generate the permutation
`static MatrixBlock`
ParamservUtils.`generateReplicationMatrix(int nsamples, int nrows, long seed)`
Generates a matrix which when left multiplied with the input matrix will replicate n data rows
`static MatrixBlock`
ParamservUtils.`generateSubsampleMatrix(int nsamples, int nrows, long seed)`
Generates a matrix which when left multiplied with the input matrix will subsample
`static MatrixBlock`
ParamservUtils.`sliceMatrixBlock(MatrixBlock mb, long rl, long rh)`
Slice the matrix block and return a matrix block (used in spark)
Methods in org.apache.sysds.runtime.controlprogram.paramserv that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.spark.api.java.JavaPairRDD<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>`
SparkParamservUtils.`assembleTrainingData(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> featuresRDD, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> labelsRDD)`
Assemble the matrix of features and labels according to the rowID
`static org.apache.spark.api.java.JavaPairRDD<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>`
SparkParamservUtils.`assembleTrainingData(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> featuresRDD, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> labelsRDD)`
Assemble the matrix of features and labels according to the rowID
`static org.apache.spark.api.java.JavaPairRDD<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>>`
SparkParamservUtils.`doPartitionOnSpark(SparkExecutionContext sec, MatrixObject features, MatrixObject labels, Statement.PSScheme scheme, int workerNum)`
`static org.apache.spark.api.java.JavaPairRDD<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>>`
SparkParamservUtils.`doPartitionOnSpark(SparkExecutionContext sec, MatrixObject features, MatrixObject labels, Statement.PSScheme scheme, int workerNum)`
Methods in org.apache.sysds.runtime.controlprogram.paramserv with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
ParamservUtils.`cbindMatrix(MatrixBlock left, MatrixBlock right)`
`static MatrixObject`
ParamservUtils.`newMatrixObject(MatrixBlock mb)`
`static MatrixObject`
ParamservUtils.`newMatrixObject(MatrixBlock mb, boolean cleanup)`
`static MatrixBlock`
ParamservUtils.`sliceMatrixBlock(MatrixBlock mb, long rl, long rh)`
Slice the matrix block and return a matrix block (used in spark)
Method parameters in org.apache.sysds.runtime.controlprogram.paramserv with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.spark.api.java.JavaPairRDD<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>`
SparkParamservUtils.`assembleTrainingData(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> featuresRDD, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> labelsRDD)`
Assemble the matrix of features and labels according to the rowID
`void`
SparkPSWorker.`call(scala.Tuple2<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>> input)`
`void`
SparkPSWorker.`call(scala.Tuple2<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>> input)`

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.paramserv.dp

Methods in org.apache.sysds.runtime.controlprogram.paramserv.dp that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
DRRLocalScheme.`removeEmpty(MatrixBlock mb, int k, int workerId)`
Methods in org.apache.sysds.runtime.controlprogram.paramserv.dp that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`scala.Tuple2<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>>`
DataPartitionerSparkAggregator.`call(scala.Tuple2<Integer,LinkedList<scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>> input)`
Row-wise combine the matrix
`scala.Tuple2<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>>`
DataPartitionerSparkAggregator.`call(scala.Tuple2<Integer,LinkedList<scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>> input)`
Row-wise combine the matrix
`Iterator<scala.Tuple2<Integer,scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>>`
DataPartitionerSparkMapper.`call(scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>> input)`
Do data partitioning
`Iterator<scala.Tuple2<Integer,scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>>`
DataPartitionerSparkMapper.`call(scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>> input)`
Do data partitioning
`static List<MatrixBlock>`
DCLocalScheme.`partition(int k, MatrixBlock mb)`
`static List<MatrixBlock>`
ORLocalScheme.`partition(int k, MatrixBlock mb, List<MatrixBlock> permutations)`
Methods in org.apache.sysds.runtime.controlprogram.paramserv.dp with parameters of type MatrixBlock
Modifier and Type
Method
Description
`abstract DataPartitionLocalScheme.Result`
DataPartitionLocalScheme.`doPartitioning(int workersNum, MatrixBlock features, MatrixBlock labels)`
`abstract org.apache.sysds.runtime.controlprogram.paramserv.dp.DataPartitionSparkScheme.Result`
DataPartitionSparkScheme.`doPartitioning(int numWorkers, int rblkID, MatrixBlock features, MatrixBlock labels)`
`DataPartitionLocalScheme.Result`
DCLocalScheme.`doPartitioning(int workersNum, MatrixBlock features, MatrixBlock labels)`
`org.apache.sysds.runtime.controlprogram.paramserv.dp.DataPartitionSparkScheme.Result`
DCSparkScheme.`doPartitioning(int numWorkers, int rblkID, MatrixBlock features, MatrixBlock labels)`
`DataPartitionLocalScheme.Result`
DRLocalScheme.`doPartitioning(int workersNum, MatrixBlock features, MatrixBlock labels)`
`DataPartitionLocalScheme.Result`
DRRLocalScheme.`doPartitioning(int workersNum, MatrixBlock features, MatrixBlock labels)`
`org.apache.sysds.runtime.controlprogram.paramserv.dp.DataPartitionSparkScheme.Result`
DRRSparkScheme.`doPartitioning(int numWorkers, int rblkID, MatrixBlock features, MatrixBlock labels)`
`org.apache.sysds.runtime.controlprogram.paramserv.dp.DataPartitionSparkScheme.Result`
DRSparkScheme.`doPartitioning(int numWorkers, int rblkID, MatrixBlock features, MatrixBlock labels)`
`DataPartitionLocalScheme.Result`
LocalDataPartitioner.`doPartitioning(int workersNum, MatrixBlock features, MatrixBlock labels)`
`DataPartitionLocalScheme.Result`
ORLocalScheme.`doPartitioning(int workersNum, MatrixBlock features, MatrixBlock labels)`
`org.apache.sysds.runtime.controlprogram.paramserv.dp.DataPartitionSparkScheme.Result`
ORSparkScheme.`doPartitioning(int numWorkers, int rblkID, MatrixBlock features, MatrixBlock labels)`
`org.apache.sysds.runtime.controlprogram.paramserv.dp.DataPartitionSparkScheme.Result`
SparkDataPartitioner.`doPartitioning(int numWorkers, MatrixBlock features, MatrixBlock labels, long rowID)`
`static List<MatrixBlock>`
DCLocalScheme.`partition(int k, MatrixBlock mb)`
`static List<MatrixBlock>`
ORLocalScheme.`partition(int k, MatrixBlock mb, List<MatrixBlock> permutations)`
`static MatrixBlock`
DRRLocalScheme.`removeEmpty(MatrixBlock mb, int k, int workerId)`
Method parameters in org.apache.sysds.runtime.controlprogram.paramserv.dp with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`scala.Tuple2<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>>`
DataPartitionerSparkAggregator.`call(scala.Tuple2<Integer,LinkedList<scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>> input)`
Row-wise combine the matrix
`scala.Tuple2<Integer,scala.Tuple2<MatrixBlock,MatrixBlock>>`
DataPartitionerSparkAggregator.`call(scala.Tuple2<Integer,LinkedList<scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>> input)`
Row-wise combine the matrix
`Iterator<scala.Tuple2<Integer,scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>>`
DataPartitionerSparkMapper.`call(scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>> input)`
Do data partitioning
`Iterator<scala.Tuple2<Integer,scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>>>>`
DataPartitionerSparkMapper.`call(scala.Tuple2<Long,scala.Tuple2<MatrixBlock,MatrixBlock>> input)`
Do data partitioning
`static List<MatrixBlock>`
ORLocalScheme.`partition(int k, MatrixBlock mb, List<MatrixBlock> permutations)`

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.parfor

Methods in org.apache.sysds.runtime.controlprogram.parfor that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
DataPartitioner.`createReuseMatrixBlock(ParForProgramBlock.PDataPartitionFormat dpf, int rows, int cols)`
Methods in org.apache.sysds.runtime.controlprogram.parfor that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ResultMergeRemoteSparkWCompare.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<Iterable<MatrixBlock>,MatrixBlock>> arg)`
Method parameters in org.apache.sysds.runtime.controlprogram.parfor with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`Iterator<scala.Tuple2<Long,org.apache.hadoop.io.Writable>>`
DataPartitionerRemoteSparkMapper.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ResultMergeRemoteSparkWCompare.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<Iterable<MatrixBlock>,MatrixBlock>> arg)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ResultMergeRemoteSparkWCompare.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<Iterable<MatrixBlock>,MatrixBlock>> arg)`

## Uses of MatrixBlock in org.apache.sysds.runtime.controlprogram.parfor.util

Fields in org.apache.sysds.runtime.controlprogram.parfor.util declared as MatrixBlock
Modifier and Type
Field
Description
`MatrixBlock`
PairWritableBlock.`block`
Constructors in org.apache.sysds.runtime.controlprogram.parfor.util with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`PairWritableBlock(MatrixIndexes ix, MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.data

Methods in org.apache.sysds.runtime.data with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
BasicTensorBlock.`set(MatrixBlock other)`
`void`
TensorBlock.`set(MatrixBlock other)`

## Uses of MatrixBlock in org.apache.sysds.runtime.einsum

Methods in org.apache.sysds.runtime.einsum that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
EOpNodeFuse.`compute(EOpNodeFuse.EinsumRewriteType rewriteType, List<MatrixBlock> ABsInput, List<MatrixBlock> mbBAs, List<MatrixBlock> mbBs, List<MatrixBlock> mbAs, List<MatrixBlock> mbAZs, Double scalar, int numThreads)`
`abstract MatrixBlock`
EOpNode.`computeEOpNode(List<MatrixBlock> inputs, int numOfThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeBinary.`computeEOpNode(List<MatrixBlock> inputs, int numThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeData.`computeEOpNode(List<MatrixBlock> inputs, int numOfThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeFuse.`computeEOpNode(List<MatrixBlock> inputs, int numThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeUnary.`computeEOpNode(List<MatrixBlock> inputs, int numOfThreads, org.apache.commons.logging.Log LOG)`
Method parameters in org.apache.sysds.runtime.einsum with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
EOpNodeFuse.`compute(EOpNodeFuse.EinsumRewriteType rewriteType, List<MatrixBlock> ABsInput, List<MatrixBlock> mbBAs, List<MatrixBlock> mbBs, List<MatrixBlock> mbAs, List<MatrixBlock> mbAZs, Double scalar, int numThreads)`
`abstract MatrixBlock`
EOpNode.`computeEOpNode(List<MatrixBlock> inputs, int numOfThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeBinary.`computeEOpNode(List<MatrixBlock> inputs, int numThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeData.`computeEOpNode(List<MatrixBlock> inputs, int numOfThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeFuse.`computeEOpNode(List<MatrixBlock> inputs, int numThreads, org.apache.commons.logging.Log LOG)`
`MatrixBlock`
EOpNodeUnary.`computeEOpNode(List<MatrixBlock> inputs, int numOfThreads, org.apache.commons.logging.Log LOG)`
`static EinsumContext`
EinsumContext.`getEinsumContext(String eqStr, List<MatrixBlock> inputs)`

## Uses of MatrixBlock in org.apache.sysds.runtime.frame.data

Methods in org.apache.sysds.runtime.frame.data with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static FrameBlock`
FrameBlock.`convertToFrameBlock(MatrixBlock mb, Types.ValueType[] schema, int k)`
`FrameBlock`
FrameBlock.`invalidByLength(MatrixBlock feaLen)`
This method validates the frame data against an attribute length constrain if data value in any cell is greater than the specified threshold of that attribute the output frame will store a null on that cell position, thus removing the length-violating values.
`FrameBlock`
FrameBlock.`removeEmptyOperations(boolean rows, boolean emptyReturn, MatrixBlock select)`

## Uses of MatrixBlock in org.apache.sysds.runtime.frame.data.lib

Methods in org.apache.sysds.runtime.frame.data.lib that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
MatrixBlockFromFrame.`convertToMatrixBlock(FrameBlock frame, int k)`
Converts a frame block with arbitrary schema into a matrix block.
`static MatrixBlock`
MatrixBlockFromFrame.`convertToMatrixBlock(FrameBlock frame, MatrixBlock ret, int k)`
Converts a frame block with arbitrary schema into a matrix block.
Methods in org.apache.sysds.runtime.frame.data.lib with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static FrameBlock`
FrameFromMatrixBlock.`convertToFrameBlock(MatrixBlock mb, int k)`
`static FrameBlock`
FrameFromMatrixBlock.`convertToFrameBlock(MatrixBlock mb, Types.ValueType[] schema, int k)`
`static FrameBlock`
FrameFromMatrixBlock.`convertToFrameBlock(MatrixBlock mb, Types.ValueType vt, int k)`
`static MatrixBlock`
MatrixBlockFromFrame.`convertToMatrixBlock(FrameBlock frame, MatrixBlock ret, int k)`
Converts a frame block with arbitrary schema into a matrix block.
`static FrameBlock`
FrameLibRemoveEmpty.`removeEmpty(FrameBlock fb, boolean rows, boolean emptyReturn, MatrixBlock select)`

## Uses of MatrixBlock in org.apache.sysds.runtime.functionobjects

Methods in org.apache.sysds.runtime.functionobjects with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
CTable.`execute(double v1, double v2, double w, boolean ignoreZeros, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
CTable.`execute(double v1, double v2, double w, boolean ignoreZeros, MatrixBlock ctableResult)`
`void`
CTable.`execute(MatrixBlock in1, MatrixBlock in2, MatrixBlock w, CTableMap resultMap, int k)`
`Callable<Object>`
CTable.`getPartialCTableTask(MatrixBlock in1, MatrixBlock in2, MatrixBlock w, int startInd, int blockSize, ArrayList<CTableMap> pmaps)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.cp

Methods in org.apache.sysds.runtime.instructions.cp with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
EinsumCPInstruction.`ensureMatrixBlockColumnVector(MatrixBlock mb)`
`static void`
EinsumCPInstruction.`ensureMatrixBlockRowVector(MatrixBlock mb)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.fed

Methods in org.apache.sysds.runtime.instructions.fed that return MatrixBlock
Modifier and Type
Method
Description
`<T> MatrixBlock`
QuantilePickFEDInstruction.`getEquiHeightBins(ExecutionContext ec, int colID, double[] quantiles)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.ooc

Methods in org.apache.sysds.runtime.instructions.ooc that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
OOCInstruction.OOCMatrixBlockTracker.`get(Long idx)`
Methods in org.apache.sysds.runtime.instructions.ooc with parameters of type MatrixBlock
Modifier and Type
Method
Description
`boolean`
OOCInstruction.OOCMatrixBlockTracker.`putAndIncrementCount(Long idx, MatrixBlock block)`
Adds or updates a block for the given index and updates its internal count.
`void`
OOCInstruction.OOCMatrixBlockTracker.`putAndInitCount(Long idx, MatrixBlock block)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.spark

Methods in org.apache.sysds.runtime.instructions.spark that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
AggregateUnarySPInstruction.RDDUAggFunction2.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`MatrixBlock`
BinUaggChainSPInstruction.RDDBinUaggChainFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CompressionSPInstruction.CompressionFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CompressionSPInstruction.CompressionWorkloadFunction.`call(MatrixBlock arg0)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature1.`call(MatrixBlock v1)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature2.`call(scala.Tuple2<MatrixBlock,MatrixBlock> v1)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature3.`call(scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock> v1)`
`MatrixBlock`
DeCompressionSPInstruction.DeCompressionFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
ParameterizedBuiltinSPInstruction.RDDMapGroupedAggFunction2.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`MatrixBlock`
ParameterizedBuiltinSPInstruction.RDDReplaceFunction.`call(MatrixBlock arg0)`
`static MatrixBlock`
MatrixIndexingSPInstruction.`inmemoryIndexing(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in1, DataCharacteristics mcIn, DataCharacteristics mcOut, IndexRange ixrange)`
Methods in org.apache.sysds.runtime.instructions.spark that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
AppendGAlignedSPInstruction.ShiftColumnIndex.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
AppendGSPInstruction.MergeWithShiftedBlocks.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<Iterable<MatrixBlock>,Iterable<MatrixBlock>>> kv)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
AppendGSPInstruction.ShiftMatrix.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
BuiltinNarySPInstruction.PadBlocksFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDMapGroupedAggFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRemoveEmptyFunction.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<MatrixBlock,MatrixBlock>> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRemoveEmptyFunctionInMem.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRExpandFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`scala.Tuple2<Long,MatrixBlock>`
ParameterizedBuiltinSPInstruction.RDDTransformApplyFunction2.`call(scala.Tuple2<Long,FrameBlock> in)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ParameterizedBuiltinSPInstruction.RDDTransformDecodeExpandFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> in)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
SpoofSPInstruction.ReplicateRightFactorFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
Methods in org.apache.sysds.runtime.instructions.spark with parameters of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
BinUaggChainSPInstruction.RDDBinUaggChainFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CompressionSPInstruction.CompressionFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CompressionSPInstruction.CompressionWorkloadFunction.`call(MatrixBlock arg0)`
`Long`
CompressionSPInstruction.SizeFunction.`call(MatrixBlock arg0)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature1.`call(MatrixBlock v1)`
`MatrixBlock`
DeCompressionSPInstruction.DeCompressionFunction.`call(MatrixBlock arg0)`
`Double`
ParameterizedBuiltinSPInstruction.RDDContainsFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
ParameterizedBuiltinSPInstruction.RDDReplaceFunction.`call(MatrixBlock arg0)`
Method parameters in org.apache.sysds.runtime.instructions.spark with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
AggregateUnarySPInstruction.RDDUAggFunction2.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
AppendGAlignedSPInstruction.ShiftColumnIndex.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
AppendGSPInstruction.MergeWithShiftedBlocks.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<Iterable<MatrixBlock>,Iterable<MatrixBlock>>> kv)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
AppendGSPInstruction.MergeWithShiftedBlocks.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<Iterable<MatrixBlock>,Iterable<MatrixBlock>>> kv)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
AppendGSPInstruction.ShiftMatrix.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
BuiltinNarySPInstruction.PadBlocksFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature2.`call(scala.Tuple2<MatrixBlock,MatrixBlock> v1)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature2.`call(scala.Tuple2<MatrixBlock,MatrixBlock> v1)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature3.`call(scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock> v1)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature3.`call(scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock> v1)`
`MatrixBlock[]`
CtableSPInstruction.MapJoinSignature3.`call(scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock> v1)`
`Iterator<scala.Tuple2<Long,Integer>>`
ParameterizedBuiltinSPInstruction.RDDContainsVectFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> input)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDMapGroupedAggFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`MatrixBlock`
ParameterizedBuiltinSPInstruction.RDDMapGroupedAggFunction2.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRemoveEmptyFunction.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<MatrixBlock,MatrixBlock>> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRemoveEmptyFunction.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<MatrixBlock,MatrixBlock>> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRemoveEmptyFunctionInMem.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ParameterizedBuiltinSPInstruction.RDDRExpandFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ParameterizedBuiltinSPInstruction.RDDTransformDecodeExpandFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> in)`
`scala.Tuple2<Long,FrameBlock>`
ParameterizedBuiltinSPInstruction.RDDTransformDecodeFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> in)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
SpoofSPInstruction.ReplicateRightFactorFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`static MatrixBlock`
MatrixIndexingSPInstruction.`inmemoryIndexing(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in1, DataCharacteristics mcIn, DataCharacteristics mcOut, IndexRange ixrange)`
Constructor parameters in org.apache.sysds.runtime.instructions.spark with type arguments of type MatrixBlock
Modifier
Constructor
Description
``
`RDDContainsVectFunction(PartitionedBroadcast<MatrixBlock> bc, int blocksize)`
``
`RDDMapGroupedAggFunction(PartitionedBroadcast<MatrixBlock> pbm, Operator op, int ngroups, int blen)`
``
`RDDMapGroupedAggFunction2(PartitionedBroadcast<MatrixBlock> pbm, Operator op, int ngroups)`
``
`RDDRemoveEmptyFunctionInMem(boolean rmRows, long len, long blen, PartitionedBroadcast<MatrixBlock> off)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.spark.data

Methods in org.apache.sysds.runtime.instructions.spark.data that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CorrMatrixBlock.`getCorrection()`
`MatrixBlock`
CorrMatrixBlock.`getValue()`
`MatrixBlock`
RowMatrixBlock.`getValue()`
Methods in org.apache.sysds.runtime.instructions.spark.data with parameters of type MatrixBlock
Modifier and Type
Method
Description
`CorrMatrixBlock`
CorrMatrixBlock.`set(MatrixBlock value, MatrixBlock corr)`
Constructors in org.apache.sysds.runtime.instructions.spark.data with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`CorrMatrixBlock(MatrixBlock value)`
``
`CorrMatrixBlock(MatrixBlock value, MatrixBlock corr)`
``
`RowMatrixBlock(int len, int row, MatrixBlock value)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.spark.functions

Methods in org.apache.sysds.runtime.instructions.spark.functions that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
AggregateDropCorrectionFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
ComputeBinaryBlockNnzFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CopyMatrixBlockFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CreateSparseBlockFunction.`call(MatrixBlock arg0)`
`MatrixBlock[]`
MapInputSignature.`call(MatrixBlock v1)`
`MatrixBlock[]`
MapJoinSignature.`call(scala.Tuple2<MatrixBlock[],MatrixBlock> v1)`
`MatrixBlock`
MatrixMatrixBinaryOpFunction.`call(scala.Tuple2<MatrixBlock,MatrixBlock> arg0)`
`MatrixBlock`
MatrixScalarUnaryFunction.`call(MatrixBlock arg0)`
Methods in org.apache.sysds.runtime.instructions.spark.functions that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`LazyIterableIterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
CopyMatrixBlockPairFunction.`call(Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ExtractBlockForBinaryReblock.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`LazyIterableIterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
MatrixVectorBinaryOpPartitionFunction.`call(Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>> arg0)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ReorgMapFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ReplicateBlockFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ReplicateVectorFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
Methods in org.apache.sysds.runtime.instructions.spark.functions with parameters of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
AggregateDropCorrectionFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
ComputeBinaryBlockNnzFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CopyMatrixBlockFunction.`call(MatrixBlock arg0)`
`MatrixBlock`
CreateSparseBlockFunction.`call(MatrixBlock arg0)`
`Boolean`
FilterNonEmptyBlocksFunction2.`call(MatrixBlock arg0)`
`MatrixBlock[]`
MapInputSignature.`call(MatrixBlock v1)`
`MatrixBlock`
MatrixScalarUnaryFunction.`call(MatrixBlock arg0)`
Method parameters in org.apache.sysds.runtime.instructions.spark.functions with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`Iterator<String>`
ConvertMatrixBlockToIJVLines.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`LazyIterableIterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
CopyMatrixBlockPairFunction.`call(Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ExtractBlockForBinaryReblock.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,WeightedCell>>`
ExtractGroup.ExtractGroupBroadcast.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg)`
`Iterator<scala.Tuple2<MatrixIndexes,WeightedCell>>`
ExtractGroup.ExtractGroupJoin.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<MatrixBlock,MatrixBlock>> arg)`
`Iterator<scala.Tuple2<MatrixIndexes,WeightedCell>>`
ExtractGroup.ExtractGroupJoin.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<MatrixBlock,MatrixBlock>> arg)`
`Iterator<scala.Tuple2<MatrixIndexes,WeightedCell>>`
ExtractGroupNWeights.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock>> arg)`
`Iterator<scala.Tuple2<MatrixIndexes,WeightedCell>>`
ExtractGroupNWeights.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock>> arg)`
`Iterator<scala.Tuple2<MatrixIndexes,WeightedCell>>`
ExtractGroupNWeights.`call(scala.Tuple2<MatrixIndexes,scala.Tuple2<scala.Tuple2<MatrixBlock,MatrixBlock>,MatrixBlock>> arg)`
`Boolean`
FilterDiagMatrixBlocksFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Boolean`
FilterNonEmptyBlocksFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Boolean`
IsBlockInList.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`Boolean`
IsBlockInRange.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> kv)`
`MatrixBlock[]`
MapJoinSignature.`call(scala.Tuple2<MatrixBlock[],MatrixBlock> v1)`
`MatrixBlock`
MatrixMatrixBinaryOpFunction.`call(scala.Tuple2<MatrixBlock,MatrixBlock> arg0)`
`MatrixBlock`
MatrixMatrixBinaryOpFunction.`call(scala.Tuple2<MatrixBlock,MatrixBlock> arg0)`
`LazyIterableIterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
MatrixVectorBinaryOpPartitionFunction.`call(Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>> arg0)`
`org.apache.sysds.runtime.instructions.spark.functions.OuterVectorBinaryOpFunction.OuterVectorBinaryOpIterator`
OuterVectorBinaryOpFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<Long>`
RecomputeNnzFunction.`call(Iterator<MatrixBlock> iter)`
`scala.Tuple2<MatrixIndexes,MatrixBlock>`
ReorgMapFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ReplicateBlockFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
ReplicateVectorFunction.`call(scala.Tuple2<MatrixIndexes,MatrixBlock> arg0)`
Constructor parameters in org.apache.sysds.runtime.instructions.spark.functions with type arguments of type MatrixBlock
Modifier
Constructor
Description
``
`ExtractGroupBroadcast(PartitionedBroadcast<MatrixBlock> pbm, long blen, long ngroups, Operator op)`
``
`MatrixVectorBinaryOpPartitionFunction(BinaryOperator op, PartitionedBroadcast<MatrixBlock> binput, BinaryM.VectorType vtype)`
``
`OuterVectorBinaryOpFunction(BinaryOperator op, PartitionedBroadcast<MatrixBlock> binput)`

## Uses of MatrixBlock in org.apache.sysds.runtime.instructions.spark.utils

Methods in org.apache.sysds.runtime.instructions.spark.utils that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
RDDAggregateUtils.`aggStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop)`
Single block aggregation over pair rdds with corrections for numerical stability.
`static MatrixBlock`
RDDAggregateUtils.`aggStable(org.apache.spark.api.java.JavaRDD<MatrixBlock> in, AggregateOperator aop)`
Single block aggregation over rdds with corrections for numerical stability.
`static MatrixBlock`
RDDAggregateUtils.`sumStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
`static MatrixBlock`
RDDAggregateUtils.`sumStable(org.apache.spark.api.java.JavaRDD<MatrixBlock> in)`
Methods in org.apache.sysds.runtime.instructions.spark.utils that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`aggByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`aggByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop, boolean deepCopyCombiner)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`aggByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop, int numPartitions, boolean deepCopyCombiner)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`binaryBlockToBinaryBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mcIn, DataCharacteristics mcOut)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
FrameRDDConverterUtils.`binaryBlockToMatrixBlock(org.apache.spark.api.java.JavaPairRDD<Long,FrameBlock> input, DataCharacteristics mcIn, DataCharacteristics mcOut)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`binaryCellToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixCell> input, DataCharacteristics mcOut, boolean outputEmptyBlocks)`
`Iterator<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
RDDConverterUtils.BinaryCellToBinaryBlockFunction.`call(Iterator<scala.Tuple2<MatrixIndexes,MatrixCell>> arg0)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtilsExt.`coordinateMatrixToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.mllib.linalg.distributed.CoordinateMatrix input, DataCharacteristics mcIn, boolean outputEmptyBlocks)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtilsExt.`coordinateMatrixToBinaryBlock(org.apache.spark.SparkContext sc, org.apache.spark.mllib.linalg.distributed.CoordinateMatrix input, DataCharacteristics mcIn, boolean outputEmptyBlocks)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkUtils.`copyBinaryBlockMatrix(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
Creates a partitioning-preserving deep copy of the input matrix RDD, where the indexes and values are copied.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkUtils.`copyBinaryBlockMatrix(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean deep)`
Creates a partitioning-preserving copy of the input matrix RDD.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`csvToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaPairRDD<org.apache.hadoop.io.LongWritable,org.apache.hadoop.io.Text> input, DataCharacteristics mc, boolean hasHeader, String delim, boolean fill, double fillValue, Set<String> naStrings)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`csvToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaRDD<String> input, DataCharacteristics mcOut, boolean hasHeader, String delim, boolean fill, double fillValue, Set<String> naStrings)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`dataFrameToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.sql.Dataset<org.apache.spark.sql.Row> df, DataCharacteristics mc, boolean containsID, boolean isVector)`
`static List<scala.Tuple2<MatrixIndexes,MatrixBlock>>`
SparkUtils.`fromIndexedMatrixBlock(List<IndexedMatrixValue> in)`
`static scala.Tuple2<MatrixIndexes,MatrixBlock>`
SparkUtils.`fromIndexedMatrixBlock(IndexedMatrixValue in)`
`static List<Pair<MatrixIndexes,MatrixBlock>>`
SparkUtils.`fromIndexedMatrixBlockToPair(List<IndexedMatrixValue> in)`
`static Pair<MatrixIndexes,MatrixBlock>`
SparkUtils.`fromIndexedMatrixBlockToPair(IndexedMatrixValue in)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkUtils.`getEmptyBlockRDD(org.apache.spark.api.java.JavaSparkContext sc, DataCharacteristics mc)`
Creates an RDD of empty blocks according to the given matrix characteristics.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`libsvmToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaPairRDD<org.apache.hadoop.io.LongWritable,org.apache.hadoop.io.Text> input, DataCharacteristics mc, String delim, String indexDelim)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`matrixBlockToAlignedMatrixBlock(org.apache.spark.api.java.JavaPairRDD<Long,MatrixBlock> input, DataCharacteristics mcIn, DataCharacteristics mcOut)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean deepCopyCombiner)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, int numPartitions, boolean deepCopyCombiner)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeRowsByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,RowMatrixBlock> in)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, long rlen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in2, long rlen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortByVals(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByIx(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> ixmap, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, boolean asc, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByValMemSort(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, boolean asc, long rlen, long clen, int blen, SparkExecutionContext sec, ReorgOperator r_op)`
This function collects and sorts value column in memory and then broadcasts it.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByVals(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, boolean asc, long rlen, long clen, long clen2, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortIndexesByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, boolean asc, long rlen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortIndexesByVals(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean asc, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`sumByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`sumByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean deepCopyCombiner)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`sumByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, int numPartitions, boolean deepCopyCombiner)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`textCellToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaPairRDD<org.apache.hadoop.io.LongWritable,org.apache.hadoop.io.Text> input, DataCharacteristics mcOut, boolean outputEmptyBlocks, FileFormatPropertiesMM mmProps)`
Methods in org.apache.sysds.runtime.instructions.spark.utils with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
RDDConverterUtilsExt.`copyRowBlocks(MatrixBlock mb, int rowIndex, MatrixBlock ret, int numRowsPerBlock, int rlen, int clen)`
`static void`
RDDConverterUtilsExt.`copyRowBlocks(MatrixBlock mb, int rowIndex, MatrixBlock ret, long numRowsPerBlock, long rlen, long clen)`
`static void`
RDDConverterUtilsExt.`copyRowBlocks(MatrixBlock mb, long rowIndex, MatrixBlock ret, int numRowsPerBlock, int rlen, int clen)`
`static void`
RDDConverterUtilsExt.`copyRowBlocks(MatrixBlock mb, long rowIndex, MatrixBlock ret, long numRowsPerBlock, long rlen, long clen)`
`static void`
RDDConverterUtilsExt.`postProcessAfterCopying(MatrixBlock ret)`
`static IndexedMatrixValue`
SparkUtils.`toIndexedMatrixBlock(MatrixIndexes ix, MatrixBlock mb)`
Method parameters in org.apache.sysds.runtime.instructions.spark.utils with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`aggByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`aggByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop, boolean deepCopyCombiner)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`aggByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop, int numPartitions, boolean deepCopyCombiner)`
`static MatrixBlock`
RDDAggregateUtils.`aggStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, AggregateOperator aop)`
Single block aggregation over pair rdds with corrections for numerical stability.
`static MatrixBlock`
RDDAggregateUtils.`aggStable(org.apache.spark.api.java.JavaRDD<MatrixBlock> in, AggregateOperator aop)`
Single block aggregation over rdds with corrections for numerical stability.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`binaryBlockToBinaryBlock(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mcIn, DataCharacteristics mcOut)`
`static org.apache.spark.api.java.JavaRDD<String>`
RDDConverterUtils.`binaryBlockToCsv(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mcIn, FileFormatPropertiesCSV props, boolean strict)`
`static org.apache.spark.sql.Dataset<org.apache.spark.sql.Row>`
RDDConverterUtils.`binaryBlockToDataFrame(org.apache.spark.sql.SparkSession sparkSession, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mc, boolean toVector)`
`static org.apache.spark.sql.Dataset<org.apache.spark.sql.Row>`
RDDConverterUtils.`binaryBlockToDataFrame(org.apache.spark.sql.SQLContext sqlContext, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mc, boolean toVector)`
Deprecated.
`static org.apache.spark.api.java.JavaRDD<org.apache.spark.ml.feature.LabeledPoint>`
RDDConverterUtils.`binaryBlockToLabeledPoints(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
Converter from binary block rdd to rdd of labeled points.
`static org.apache.spark.api.java.JavaRDD<String>`
RDDConverterUtils.`binaryBlockToLibsvm(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mcIn, FileFormatPropertiesLIBSVM props, boolean strict)`
`static org.apache.spark.api.java.JavaRDD<String>`
RDDConverterUtils.`binaryBlockToTextCell(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, DataCharacteristics mc)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkUtils.`copyBinaryBlockMatrix(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
Creates a partitioning-preserving deep copy of the input matrix RDD, where the indexes and values are copied.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
SparkUtils.`copyBinaryBlockMatrix(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean deep)`
Creates a partitioning-preserving copy of the input matrix RDD.
`static long`
SparkUtils.`getNonZeros(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> input)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDConverterUtils.`matrixBlockToAlignedMatrixBlock(org.apache.spark.api.java.JavaPairRDD<Long,MatrixBlock> input, DataCharacteristics mcIn, DataCharacteristics mcOut)`
`static org.apache.spark.api.java.JavaPairRDD<org.apache.hadoop.io.LongWritable,FrameBlock>`
FrameRDDConverterUtils.`matrixBlockToBinaryBlock(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> input, DataCharacteristics mcIn)`
`static org.apache.spark.api.java.JavaPairRDD<Long,FrameBlock>`
FrameRDDConverterUtils.`matrixBlockToBinaryBlockLongIndex(org.apache.spark.api.java.JavaSparkContext sc, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> input, DataCharacteristics dcIn)`
`static double`
RDDAggregateUtils.`max(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean deepCopyCombiner)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`mergeByKey(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, int numPartitions, boolean deepCopyCombiner)`
Merges disjoint data of all blocks per key.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, long rlen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in2, long rlen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortByVals(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByIx(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> ixmap, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, boolean asc, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByValMemSort(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, boolean asc, long rlen, long clen, int blen, SparkExecutionContext sec, ReorgOperator r_op)`
This function collects and sorts value column in memory and then broadcasts it.
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortDataByVals(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> data, boolean asc, long rlen, long clen, long clen2, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortIndexesByVal(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> val, boolean asc, long rlen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDSortUtils.`sortIndexesByVals(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean asc, long rlen, long clen, int blen)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`sumByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`sumByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, boolean deepCopyCombiner)`
`static org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock>`
RDDAggregateUtils.`sumByKeyStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in, int numPartitions, boolean deepCopyCombiner)`
`static MatrixBlock`
RDDAggregateUtils.`sumStable(org.apache.spark.api.java.JavaPairRDD<MatrixIndexes,MatrixBlock> in)`
`static MatrixBlock`
RDDAggregateUtils.`sumStable(org.apache.spark.api.java.JavaRDD<MatrixBlock> in)`
`static IndexedMatrixValue`
SparkUtils.`toIndexedMatrixBlock(scala.Tuple2<MatrixIndexes,MatrixBlock> in)`

## Uses of MatrixBlock in org.apache.sysds.runtime.io

Methods in org.apache.sysds.runtime.io that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
ReaderCOGParallel.TileProcessor.`call()`
`static MatrixBlock`
ReaderHDF5.`computeHDF5Size(List<org.apache.hadoop.fs.Path> files, org.apache.hadoop.fs.FileSystem fs, String datasetName, long estnnz)`
`static MatrixBlock[]`
MatrixWriter.`createMatrixBlocksForReuse(long rlen, long clen, int blen, boolean sparse, long nonZeros)`
`MatrixBlock`
BinaryBlockSerialization.MatrixBlockDeserializer.`deserialize(MatrixBlock mb)`
`static MatrixBlock`
MatrixWriter.`getMatrixBlockForReuse(MatrixBlock[] blocks, int rows, int cols, int blen)`
`MatrixBlock`
ReaderTextCSVParallel.`readMatrixAsStream(OOCStream<IndexedMatrixValue> outStream, String fname, long rlen, long clen, int blen, long estnnz)`
`abstract MatrixBlock`
MatrixReader.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderBinaryBlock.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderBinaryBlockParallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderCOG.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderCOGParallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderDelta.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderDeltaParallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderHDF5.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderHDF5Parallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextCell.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextCSV.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextCSVParallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextLIBSVM.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextLIBSVMParallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`abstract MatrixBlock`
MatrixReader.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderBinaryBlock.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderCOG.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderCOGParallel.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderDelta.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderHDF5.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderHDF5Parallel.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextCell.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextCSV.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextCSVParallel.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextLIBSVM.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
ReaderTextLIBSVMParallel.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
Methods in org.apache.sysds.runtime.io that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`org.apache.hadoop.io.serializer.Deserializer<MatrixBlock>`
BinaryBlockSerialization.`getDeserializer(Class arg0)`
`org.apache.hadoop.io.serializer.Serializer<MatrixBlock>`
BinaryBlockSerialization.`getSerializer(Class arg0)`
Methods in org.apache.sysds.runtime.io with parameters of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
BinaryBlockSerialization.MatrixBlockDeserializer.`deserialize(MatrixBlock mb)`
`static MatrixBlock`
MatrixWriter.`getMatrixBlockForReuse(MatrixBlock[] blocks, int rows, int cols, int blen)`
`static long`
ReaderHDF5.`readMatrixFromHDF5(H5ByteReader byteReader, String datasetName, MatrixBlock dest, int rl, long ru, long clen, int blen)`
`void`
BinaryBlockSerialization.MatrixBlockSerializer.`serialize(MatrixBlock mb)`
`void`
WriterHDF5Parallel.`writeHDF5MatrixToHDFS(org.apache.hadoop.fs.Path path, org.apache.hadoop.mapred.JobConf job, org.apache.hadoop.fs.FileSystem fs, MatrixBlock src)`
`void`
MatrixWriter.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz)`
`abstract void`
MatrixWriter.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`final void`
WriterBinaryBlock.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`void`
WriterDelta.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`void`
WriterHDF5.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`final void`
WriterMatrixMarket.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`final void`
WriterTextCell.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`final void`
WriterTextCSV.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
`final void`
WriterTextLIBSVM.`writeMatrixToHDFS(MatrixBlock src, String fname, long rlen, long clen, int blen, long nnz, boolean diag)`
Constructors in org.apache.sysds.runtime.io with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`ReadTask(org.apache.hadoop.mapred.InputSplit split, org.apache.hadoop.mapred.TextInputFormat informat, org.apache.hadoop.mapred.JobConf job, MatrixBlock dest, long rlen, long clen, boolean mm, FileFormatPropertiesMM mmProps)`
``
`TileProcessor(int clen, byte[] tileData, int tileRow, int tileCol, int tileWidth, int tileLength, int bands, int[] bitsPerSample, SampleFormatDataTypes[] sampleFormat, COGHeader cogHeader, MatrixBlock dest, int planarConfiguration)`
``
`TileProcessor(int clen, byte[] tileData, int tileRow, int tileCol, int tileWidth, int tileLength, int bands, int[] bitsPerSample, SampleFormatDataTypes[] sampleFormat, COGHeader cogHeader, MatrixBlock dest, int planarConfiguration, int band)`

## Uses of MatrixBlock in org.apache.sysds.runtime.iogen

Methods in org.apache.sysds.runtime.iogen that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
SampleProperties.`getSampleMatrix()`
Methods in org.apache.sysds.runtime.iogen with parameters of type MatrixBlock
Modifier and Type
Method
Description
`void`
SampleProperties.`setSampleMatrix(MatrixBlock sampleMatrix)`
Constructors in org.apache.sysds.runtime.iogen with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`FormatIdentifyer(String raw, MatrixBlock matrix)`
``
`GenerateReaderMatrix(String sampleRaw, MatrixBlock sampleMatrix, boolean parallel)`
``
`ReaderMapping(int nlines, int nrows, int ncols, RawIndex[] sampleRawIndexes, MatrixBlock matrix)`
``
`ReaderMapping(String raw, MatrixBlock matrix)`
``
`ReaderMappingIndex(int nlines, int nrows, int ncols, RawIndex[] sampleRawIndexes, MatrixBlock matrix)`
``
`ReaderMappingIndex(String raw, MatrixBlock matrix)`
``
`SampleProperties(String sampleRaw, MatrixBlock sampleMatrix)`

## Uses of MatrixBlock in org.apache.sysds.runtime.iogen.template

Methods in org.apache.sysds.runtime.iogen.template that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MatrixGenerateReader.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
MatrixGenerateReaderParallel.`readMatrixFromHDFS(String fname, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
MatrixGenerateReader.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`
`MatrixBlock`
MatrixGenerateReaderParallel.`readMatrixFromInputStream(InputStream is, long rlen, long clen, int blen, long estnnz)`

## Uses of MatrixBlock in org.apache.sysds.runtime.lineage

Methods in org.apache.sysds.runtime.lineage that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
LineageCache.`getMatrix(LineageItem key)`
`MatrixBlock`
LineageCacheEntry.`getMBValue()`
Methods in org.apache.sysds.runtime.lineage with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
LineageCache.`putValueAsyncOp(LineageItem instLI, Data data, MatrixBlock mb, long starttime)`
`void`
LineageCacheEntry.`setValue(MatrixBlock val)`
`void`
LineageCacheEntry.`setValue(MatrixBlock val, long computetime)`
Constructors in org.apache.sysds.runtime.lineage with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`LineageCacheEntry(LineageItem key, Types.DataType dt, MatrixBlock Mval, ScalarObject Sval, long computetime)`

## Uses of MatrixBlock in org.apache.sysds.runtime.matrix.data

Fields in org.apache.sysds.runtime.matrix.data declared as MatrixBlock
Modifier and Type
Field
Description
`MatrixBlock`
DnnParameters.`bias`
`MatrixBlock`
DnnParameters.`input1`
`MatrixBlock`
DnnParameters.`input2`
`MatrixBlock`
DnnParameters.`input3`
`MatrixBlock`
DnnParameters.`input4`
`MatrixBlock`
DnnParameters.`input5`
`MatrixBlock`
DnnParameters.`input6`
`MatrixBlock`
DnnParameters.`input7`
`MatrixBlock`
DnnParameters.`input8`
`MatrixBlock`
DnnParameters.`input9`
`MatrixBlock`
DnnParameters.`output`
`MatrixBlock`
DnnParameters.`output2`
`MatrixBlock`
DnnParameters.`output3`
`MatrixBlock`
DnnParameters.`output4`
`MatrixBlock`
DnnParameters.`output5`
Methods in org.apache.sysds.runtime.matrix.data that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, AggregateBinaryOperator op)`
`final MatrixBlock`
MatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, AggregateBinaryOperator op)`
`static MatrixBlock`
LibMatrixAgg.`aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op)`
`static MatrixBlock`
LibMatrixAgg.`aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op, int k)`
`static MatrixBlock`
MatrixBlock.`aggregateTernaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, AggregateTernaryOperator op, boolean inCP)`
`static MatrixBlock`
LibMatrixAgg.`aggregateUnaryMatrix(AggregateUnaryOperator op, MatrixBlock in, MatrixValue result, int blen, MatrixIndexes indexesIn, boolean inCP)`
`final MatrixBlock`
MatrixBlock.`aggregateUnaryOperations(AggregateUnaryOperator op)`
`MatrixBlock`
MatrixBlock.`aggregateUnaryOperations(AggregateUnaryOperator op, MatrixValue result, int blen, MatrixIndexes indexesIn, boolean inCP)`
`final MatrixBlock`
MatrixBlock.`allocateBlock()`
`final MatrixBlock`
MatrixBlock.`allocateDenseBlock()`
`static MatrixBlock`
LibMatrixAppend.`append(MatrixBlock a, MatrixBlock[] that, MatrixBlock result, boolean cbind)`
`static MatrixBlock`
MatrixBlock.`append(List<MatrixBlock> that, MatrixBlock ret, boolean cbind, int k)`
Append that list of matrixblocks together.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that)`
Append that matrix to this matrix, while allocating a new matrix.
`MatrixBlock`
MatrixBlock.`append(MatrixBlock[] that, MatrixBlock result, boolean cbind)`
Append that list of matrixes to this matrix.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that, boolean cbind)`
Append that matrix to this matrix, while allocating a new matrix.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that, MatrixBlock ret)`
Append that matrix to this matrix.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that, MatrixBlock ret, boolean cbind)`
Append that matrix to this matrix.
`final MatrixBlock`
MatrixBlock.`binaryOperations(BinaryOperator op, MatrixValue thatValue)`
`MatrixBlock`
MatrixBlock.`binaryOperations(BinaryOperator op, MatrixValue thatValue, MatrixValue result)`
`MatrixBlock`
MatrixBlock.`binaryOperationsInPlace(BinaryOperator op, MatrixValue thatValue)`
`static MatrixBlock`
LibMatrixBincell.`bincellOp(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op)`
`static MatrixBlock`
LibMatrixBincell.`bincellOpInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op)`
NOTE: operations in place always require m1 and m2 to be of equal dimensions defaults to right side operations, updating the m1 matrix with like: m1ret op m2
`static MatrixBlock`
LibMatrixBincell.`bincellOpInPlaceLeft(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op)`
Left side operations, updating the m1 matrix like: m2 op m1ret
`static MatrixBlock`
LibMatrixBincell.`bincellOpInPlaceRight(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op)`
Right side operations, updating the m1 matrix like: m1ret op m2
`static MatrixBlock`
LibMatrixBincell.`bincellOpScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op, int k)`
`MatrixBlock`
MatrixBlock.`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype)`
`MatrixBlock`
MatrixBlock.`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype, int k)`
`final MatrixBlock`
MatrixBlock.`colMax()`
Wrapper method for reduceall-colMin of a matrix.
`final MatrixBlock`
MatrixBlock.`colMax(int k)`
`final MatrixBlock`
MatrixBlock.`colMin()`
Wrapper method for reduceall-colMin of a matrix.
`final MatrixBlock`
MatrixBlock.`colMin(int k)`
`MatrixBlock`
MatrixBlock.`colSum()`
Wrapper method for single threaded reduceall-colSum of a matrix.
`static MatrixBlock`
LibCommonsMath.`computeSolve(MatrixBlock in1, MatrixBlock in2)`
Function to solve a given system of equations.
`MatrixBlock`
MatrixBlock.`copyShallow(MatrixBlock that)`
`static MatrixBlock`
LibMatrixCountDistinct.`countDistinctValuesFromSketch(CountDistinctOperator op, CorrMatrixBlock corrBlkIn)`
`final MatrixBlock`
MatrixBlock.`ctableSeqOperations(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)
`MatrixBlock`
MatrixBlock.`ctableSeqOperations(MatrixValue thatMatrix, double thatScalar, MatrixBlock ret, boolean updateClen)`
D = ctable(seq,A,w)
`static MatrixBlock`
LibMatrixAgg.`cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop)`
`static MatrixBlock`
LibMatrixAgg.`cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop, double[] agg)`
`static MatrixBlock`
LibMatrixAgg.`cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop, int k)`
`static MatrixBlock`
LibMatrixReorg.`diag(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixMult.`emptyMatrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret)`
`static MatrixBlock`
LibMatrixCountDistinct.`estimateDistinctValues(MatrixBlock in, CountDistinctOperator op)`
Public method to count the number of distinct values inside a matrix.
`MatrixBlock`
MatrixBlock.`extractTriangular(MatrixBlock ret, boolean lower, boolean diag, boolean values)`
`static MatrixBlock[]`
LibMatrixFourier.`fft(MatrixBlock re, int threads)`
Function to perform FFT for a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`fft(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform FFT for two given matrices.
`static MatrixBlock[]`
LibMatrixFourier.`fft_linearized(MatrixBlock re, int threads)`
Function to perform FFT for each row of a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`fft_linearized(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform FFT for each row of two given matrices.
`MatrixBlock`
MatrixBlock.`fill(double v)`
`static MatrixBlock`
LibMatrixReorg.`fusedSeqRexpand(int seqHeight, MatrixBlock A, double w)`
The DML code to activate this function:
`static MatrixBlock`
LibMatrixReorg.`fusedSeqRexpand(int seqHeight, MatrixBlock A, double w, MatrixBlock ret, boolean updateClen)`
The DML code to activate this function:
`static MatrixBlock`
LibMatrixReorg.`fusedSeqRexpand(int seqHeight, MatrixBlock A, double w, MatrixBlock ret, boolean updateClen, int k)`
The DML code to activate this function:
`static MatrixBlock`
LibMatrixSketch.`getUniqueValues(MatrixBlock blkIn, Types.Direction dir)`
`final MatrixBlock`
MatrixBlock.`groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, Operator op)`
Invocation from CP instructions.
`MatrixBlock`
MatrixBlock.`groupedAggOperations(MatrixValue tgt, MatrixValue wghts, MatrixValue ret, int ngroups, Operator op, int k)`
`static MatrixBlock[]`
LibMatrixFourier.`ifft(MatrixBlock re, int threads)`
Function to perform IFFT for a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`ifft(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform IFFT for two given matrices.
`static MatrixBlock[]`
LibMatrixFourier.`ifft_linearized(MatrixBlock re, int threads)`
Function to perform IFFT for each row of a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`ifft_linearized(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform IFFT for each row of two given matrices.
`MatrixBlock`
MatrixBlock.`leftIndexingOperations(ScalarObject scalar, int rl, int cl, MatrixBlock ret, MatrixObject.UpdateType update)`
Explicitly allow left indexing for scalars.
`MatrixBlock`
MatrixBlock.`leftIndexingOperations(MatrixBlock rhsMatrix, int rl, int ru, int cl, int cu, MatrixBlock ret, MatrixObject.UpdateType update)`
`final MatrixBlock`
MatrixBlock.`leftIndexingOperations(MatrixBlock rhsMatrix, IndexRange ixrange, MatrixBlock ret, MatrixObject.UpdateType update)`
`static MatrixBlock`
OperationsOnMatrixValues.`matMult(MatrixBlock value1, MatrixBlock value2, MatrixBlock valueOut, AggregateBinaryOperator op)`
`static MatrixBlock`
OperationsOnMatrixValues.`matMult(MatrixBlock value1, MatrixBlock value2, AggregateBinaryOperator op)`
`static MatrixBlock`
OperationsOnMatrixValues.`matMult(MatrixIndexes indexes1, MatrixBlock value1, MatrixIndexes indexes2, MatrixBlock value2, MatrixIndexes indexesOut, MatrixBlock valueOut, AggregateBinaryOperator op)`
`static MatrixBlock`
LibCommonsMath.`matrixMatrixOperations(MatrixBlock in1, MatrixBlock in2, String opcode)`
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2)`
Performs a matrix multiplication All variants use a IKJ access pattern, and internally use dense output.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, int k)`
Performs a matrix multiplication All variants use a IKJ access pattern, and internally use dense output.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret)`
Performs a matrix multiplication and stores the result in the output matrix.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, boolean fixedRet)`
This method allows one to disabling exam sparsity.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, boolean fixedRet, int k)`
Performs a matrix multiplication and stores the result in the output matrix.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
Performs a multi-threaded matrix multiplication and stores the result in the output matrix.
`static MatrixBlock`
LibMatrixNative.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
Performs matrix multiplication using native library if BLAS is available or else falls back to Java BLAS.
`static MatrixBlock`
LibMatrixMult.`matrixMultNonNative(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
`static MatrixBlock`
LibMatrixMult.`matrixMultTransposeSelf(MatrixBlock m1, MatrixBlock ret, boolean leftTranspose)`
`MatrixBlock`
MatrixBlock.`max(int k)`
Wrapper method for reduceall-max of a matrix.
`MatrixBlock`
MatrixBlock.`merge(MatrixBlock that, boolean appendOnly)`
`MatrixBlock`
MatrixBlock.`merge(MatrixBlock that, boolean appendOnly, boolean par)`
`MatrixBlock`
MatrixBlock.`merge(MatrixBlock that, boolean appendOnly, boolean par, boolean deep)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in, String opcode, int threads)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in, String opcode, int threads, int num_iterations, double tol)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in, String opcode, int threads, long seed)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in1, MatrixBlock in2, String opcode)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in1, MatrixBlock in2, String opcode, int threads, long seed)`
`static MatrixBlock`
MatrixBlock.`naryOperations(Operator op, MatrixBlock[] matrices, ScalarObject[] scalars, MatrixBlock ret)`
`static MatrixBlock`
LibMatrixReorg.`permute(MatrixBlock in, int[] inDims, int[] perm)`
`static MatrixBlock`
LibMatrixReorg.`permute(MatrixBlock in, int[] inDims, int[] perm, int k)`
`final MatrixBlock`
MatrixBlock.`pickValues(MatrixValue quantiles, MatrixValue ret)`
Pick the quantiles out of this matrix.
`MatrixBlock`
MatrixBlock.`pickValues(MatrixValue quantiles, MatrixValue ret, boolean average)`
`static MatrixBlock`
LibMatrixAgg.`prepareAggregateUnaryOutput(MatrixBlock in, AggregateUnaryOperator op, MatrixValue result, int blen)`
`static MatrixBlock`
LibMatrixMult.`prepMatrixMultTransposeSelfInput(MatrixBlock m1, boolean leftTranspose, boolean par)`
`final MatrixBlock`
MatrixBlock.`quaternaryOperations(QuaternaryOperator qop, MatrixBlock um, MatrixBlock vm, MatrixBlock wm, MatrixBlock out)`
`MatrixBlock`
MatrixBlock.`quaternaryOperations(QuaternaryOperator qop, MatrixBlock U, MatrixBlock V, MatrixBlock wm, MatrixBlock out, int k)`
`static MatrixBlock`
MatrixBlock.`randOperations(int rows, int cols, double sparsity)`
`static MatrixBlock`
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`
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`
MatrixBlock.`randOperations(RandomMatrixGenerator rgen, long seed)`
Function to generate the random matrix with specified dimensions and block dimensions.
`static MatrixBlock`
MatrixBlock.`randOperations(RandomMatrixGenerator rgen, long seed, int k)`
Function to generate the random matrix with specified dimensions and block dimensions.
`MatrixBlock`
MatrixBlock.`randOperationsInPlace(RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed)`
Function to generate a matrix of random numbers.
`MatrixBlock`
MatrixBlock.`randOperationsInPlace(RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed, int k)`
Function to generate a matrix of random numbers.
`final MatrixBlock`
MatrixBlock.`rbind(MatrixBlock that)`
`final MatrixBlock`
MatrixBlock.`removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn)`
`MatrixBlock`
MatrixBlock.`removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
`static MatrixBlock`
LibMatrixReorg.`removeEmptyRows(MatrixBlock in, MatrixBlock ret, boolean emptyReturn, boolean selectNull, boolean[] flags, int rlen2)`
Remove selected rows, based on the boolean array given.
`static MatrixBlock`
LibMatrixReorg.`reorg(MatrixBlock in, MatrixBlock out, ReorgOperator op)`
`static MatrixBlock`
LibMatrixReorg.`reorgInPlace(MatrixBlock in, ReorgOperator op)`
`MatrixBlock`
MatrixBlock.`reorgOperations(ReorgOperator op, MatrixValue ret, int startRow, int startColumn, int length)`
`static MatrixBlock`
LibMatrixReplace.`replaceOperations(MatrixBlock in, MatrixBlock ret, double pattern, double replacement)`
`static MatrixBlock`
LibMatrixReplace.`replaceOperations(MatrixBlock in, MatrixBlock ret, double pattern, double replacement, int k)`
`final MatrixBlock`
MatrixBlock.`replaceOperations(MatrixValue result, double pattern, double replacement)`
`MatrixBlock`
MatrixBlock.`replaceOperations(MatrixValue result, double pattern, double replacement, int k)`
`static MatrixBlock`
LibMatrixReorg.`reshape(MatrixBlock in, int rows, int cols, boolean rowwise)`
CP reshape operation (single input, single output matrix) NOTE: In contrast to R, the rowwise parameter specifies both the read and write order, with row-wise being the default, while R uses always a column-wise read, rowwise specifying the write order and column-wise being the default.
`static MatrixBlock`
LibMatrixReorg.`reshape(MatrixBlock in, MatrixBlock out, int rows, int cols, boolean rowwise)`
CP reshape operation (single input, single output matrix) NOTE: In contrast to R, the rowwise parameter specifies both the read and write order, with row-wise being the default, while R uses always a column-wise read, rowwise specifying the write order and column-wise being the default.
`static MatrixBlock`
LibMatrixReorg.`reshape(MatrixBlock in, MatrixBlock out, int rows, int cols, boolean rowwise, int k)`
CP reshape operation (single input, single output matrix) NOTE: In contrast to R, the rowwise parameter specifies both the read and write order, with row-wise being the default, while R uses always a column-wise read, rowwise specifying the write order and column-wise being the default.
`MatrixBlock`
MatrixBlock.`reshape(int rows, int cols, boolean byRow)`
`static MatrixBlock`
LibMatrixReorg.`rev(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixReorg.`rev(MatrixBlock in, MatrixBlock out, int k)`
`static MatrixBlock`
LibMatrixReorg.`rexpand(MatrixBlock in, MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
CP rexpand operation (single input, single output), the classic example of this operation is one hot encoding of a column to multiple columns.
`static MatrixBlock`
LibMatrixReorg.`rexpand(MatrixBlock in, MatrixBlock ret, int max, boolean rows, boolean cast, boolean ignore, int k)`
CP rexpand operation (single input, single output), the classic example of this operation is one hot encoding of a column to multiple columns.
`MatrixBlock`
MatrixBlock.`rexpandOperations(MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
`static MatrixBlock`
LibMatrixReorg.`rmempty(MatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
CP rmempty operation (single input, single output matrix)
`static MatrixBlock`
LibMatrixReorg.`rmemptyEarlyAbort(MatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
Handle the early-termination cases of removeEmpty that do not require scanning for empty rows/columns.
`static MatrixBlock`
LibMatrixReorg.`rmemptyUnsafe(MatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
`static MatrixBlock`
LibMatrixReorg.`roll(MatrixBlock in, MatrixBlock out, int shift)`
`static MatrixBlock`
LibMatrixReorg.`roll(MatrixBlock input, MatrixBlock output, int shift, int numThreads)`
`final MatrixBlock`
MatrixBlock.`rowSum()`
Wrapper method for single threaded reduceall-rowSum of a matrix.
`final MatrixBlock`
MatrixBlock.`rowSum(int k)`
Wrapper method for multi threaded reduceall-rowSum of a matrix.
`static MatrixBlock`
MatrixBlock.`sampleOperations(long range, int size, boolean replace, long seed)`
`MatrixBlock`
MatrixBlock.`scalarOperations(ScalarOperator op, MatrixValue result)`
`static MatrixBlock`
MatrixBlock.`seqOperations(double from, double to, double incr)`
Method to generate a sequence according to the given parameters.
`MatrixBlock`
MatrixBlock.`seqOperationsInPlace(double from, double to, double incr)`
`final MatrixBlock`
MatrixBlock.`slice(int rl, int ru)`
`final MatrixBlock`
MatrixBlock.`slice(int rl, int ru, boolean deep)`
`final MatrixBlock`
MatrixBlock.`slice(int rl, int ru, int cl, int cu)`
`final MatrixBlock`
MatrixBlock.`slice(int rl, int ru, int cl, int cu, boolean deep)`
`MatrixBlock`
MatrixBlock.`slice(int rl, int ru, int cl, int cu, boolean deep, MatrixBlock ret)`
`final MatrixBlock`
MatrixBlock.`slice(int rl, int ru, int cl, int cu, MatrixBlock ret)`
`final MatrixBlock`
MatrixBlock.`slice(IndexRange ixrange, MatrixBlock ret)`
`static MatrixBlock`
LibMatrixReorg.`sort(MatrixBlock in, MatrixBlock out, int[] by, boolean desc, boolean ixret)`
`static MatrixBlock`
LibMatrixReorg.`sort(MatrixBlock in, MatrixBlock out, int[] by, boolean desc, boolean ixret, int k)`
`final MatrixBlock`
MatrixBlock.`sortOperations()`
`final MatrixBlock`
MatrixBlock.`sortOperations(MatrixValue weights)`
`final MatrixBlock`
MatrixBlock.`sortOperations(MatrixValue weights, MatrixBlock result)`
`MatrixBlock`
MatrixBlock.`sortOperations(MatrixValue weights, MatrixBlock result, int k)`
`final MatrixBlock`
MatrixBlock.`sparseToDense()`
`MatrixBlock`
MatrixBlock.`sparseToDense(int k)`
`static MatrixBlock[]`
LibMatrixSTFT.`stft(MatrixBlock re, int windowSize, int overlap, int threads)`
Function to perform STFT on a given matrices with windowSize and overlap.
`static MatrixBlock[]`
LibMatrixSTFT.`stft(MatrixBlock re, MatrixBlock im, int windowSize, int overlap, int threads)`
Function to perform STFT on two given matrices with windowSize and overlap.
`MatrixBlock`
MatrixBlock.`sum(int k)`
Wrapper method for reduceall-sum of a matrix parallel
`final MatrixBlock`
MatrixBlock.`ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3)`
`MatrixBlock`
MatrixBlock.`ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret)`
`MatrixBlock`
CTableMap.`toMatrixBlock(int rlen, int clen)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, int k)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, int k, boolean allowCSR)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, MatrixBlock out, int k)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, MatrixBlock out, int k, boolean allowCSR)`
`final MatrixBlock`
MatrixBlock.`transpose()`
Transpose this MatrixBlock
`MatrixBlock`
MatrixBlock.`transpose(int k)`
Transpose this MatrixBlock leveraging parallelzation degree k
`static MatrixBlock`
LibMatrixReorg.`transposeInPlace(MatrixBlock in, int k)`
`MatrixBlock`
MatrixBlock.`transposeSelfMatrixMultOperations(MatrixBlock out, MMTSJ.MMTSJType tstype)`
`MatrixBlock`
MatrixBlock.`transposeSelfMatrixMultOperations(MatrixBlock out, MMTSJ.MMTSJType tstype, int k)`
`MatrixBlock`
MatrixBlock.`uaggouterchainOperations(MatrixBlock mbLeft, MatrixBlock mbRight, MatrixBlock mbOut, BinaryOperator bOp, AggregateUnaryOperator uaggOp)`
`static MatrixBlock`
LibCommonsMath.`unaryOperations(MatrixBlock inj, String opcode)`
`final MatrixBlock`
MatrixBlock.`unaryOperations(UnaryOperator op)`
`MatrixBlock`
MatrixBlock.`unaryOperations(UnaryOperator op, MatrixValue result)`
`static MatrixBlock`
LibMatrixBincell.`uncellOp(MatrixBlock m1, MatrixBlock ret, UnaryOperator op)`
`MatrixBlock`
MatrixBlock.`unionOperations(MatrixBlock m1, MatrixBlock m2)`
`MatrixBlock`
MatrixBlock.`zeroOutOperations(MatrixValue result, IndexRange range)`
Methods in org.apache.sysds.runtime.matrix.data that return types with arguments of type MatrixBlock
Modifier and Type
Method
Description
`Future<MatrixBlock>`
MatrixBlock.`allocateBlockAsync()`
Methods in org.apache.sysds.runtime.matrix.data with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static void`
LibMatrixAgg.`aggregateBinaryMatrix(MatrixBlock in, MatrixBlock aggVal, MatrixBlock aggCorr, boolean deep)`
Core incremental matrix aggregate (ak+) as used in mapmult, tsmm, cpmm, etc.
`static void`
LibMatrixAgg.`aggregateBinaryMatrix(MatrixBlock in, MatrixBlock aggVal, AggregateOperator aop)`
Core incremental matrix aggregate (ak+) as used for uack+ and acrk+.
`MatrixBlock`
MatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, AggregateBinaryOperator op)`
`final MatrixBlock`
MatrixBlock.`aggregateBinaryOperations(MatrixBlock m1, MatrixBlock m2, AggregateBinaryOperator op)`
`static CmCovObject`
LibMatrixAgg.`aggregateCmCov(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, ValueFunction fn)`
Single threaded Covariance and Central Moment operations CM = Central Moment COV = Covariance
`static CmCovObject`
LibMatrixAgg.`aggregateCmCov(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, ValueFunction fn, int k)`
Multi threaded Covariance and Central Moment operations CM = Central Moment COV = Covariance
`static void`
LibMatrixOuterAgg.`aggregateMatrix(MatrixBlock in1Val, MatrixBlock outVal, double[] bv, int[] bvi, BinaryOperator bOp, AggregateUnaryOperator uaggOp)`
`static MatrixBlock`
LibMatrixAgg.`aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op)`
`static MatrixBlock`
LibMatrixAgg.`aggregateTernary(MatrixBlock in1, MatrixBlock in2, MatrixBlock in3, MatrixBlock ret, AggregateTernaryOperator op, int k)`
`static MatrixBlock`
MatrixBlock.`aggregateTernaryOperations(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, AggregateTernaryOperator op, boolean inCP)`
`static void`
LibMatrixAggUnarySpecialization.`aggregateUnary(MatrixBlock mb, AggregateUnaryOperator op, MatrixBlock result, int blen, MatrixIndexes indexesIn)`
`static void`
LibMatrixAgg.`aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop)`
`static void`
LibMatrixAgg.`aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop, boolean allowReformatToSparse)`
`static void`
LibMatrixAgg.`aggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop, int k)`
`static MatrixBlock`
LibMatrixAgg.`aggregateUnaryMatrix(AggregateUnaryOperator op, MatrixBlock in, MatrixValue result, int blen, MatrixIndexes indexesIn, boolean inCP)`
`static MatrixBlock`
LibMatrixAppend.`append(MatrixBlock a, MatrixBlock[] that, MatrixBlock result, boolean cbind)`
`static MatrixBlock`
MatrixBlock.`append(List<MatrixBlock> that, MatrixBlock ret, boolean cbind, int k)`
Append that list of matrixblocks together.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that)`
Append that matrix to this matrix, while allocating a new matrix.
`MatrixBlock`
MatrixBlock.`append(MatrixBlock[] that, MatrixBlock result, boolean cbind)`
Append that list of matrixes to this matrix.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that, boolean cbind)`
Append that matrix to this matrix, while allocating a new matrix.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that, MatrixBlock ret)`
Append that matrix to this matrix.
`final MatrixBlock`
MatrixBlock.`append(MatrixBlock that, MatrixBlock ret, boolean cbind)`
Append that matrix to this matrix.
`void`
MatrixBlock.`appendRowToSparse(SparseBlock dest, MatrixBlock src, int i, int rowoffset, int coloffset, boolean deep)`
`void`
MatrixBlock.`appendToSparse(MatrixBlock that, int rowoffset, int coloffset)`
`static void`
LibMatrixDNN.`batchNorm2D(MatrixBlock image, MatrixBlock scale, MatrixBlock bias, MatrixBlock runningMean, MatrixBlock runningVar, String phase, double epsilon, double mu, MatrixBlock ret, MatrixBlock retRunningMean, MatrixBlock retRunningVar, MatrixBlock resultSaveMean, MatrixBlock resultSaveInvVariance)`
`static void`
LibMatrixDNN.`batchNorm2DBackward(MatrixBlock image, MatrixBlock dout, MatrixBlock scale, double epsilon, MatrixBlock resultSaveMean, MatrixBlock resultSaveInvVariance, MatrixBlock dX, MatrixBlock dScale, MatrixBlock dBias)`
`static void`
LibMatrixDNN.`biasAdd(MatrixBlock input, MatrixBlock bias, MatrixBlock outputBlock, int numThreads)`
Performs the operation corresponding to the DML script: ones = matrix(1, rows=1, cols=Hout*Wout) output = input + matrix(bias %*% ones, rows=1, cols=F*Hout*Wout) This operation is often followed by conv2d and hence we have introduced bias_add(input, bias) built-in function
`static void`
LibMatrixDNN.`biasMultiply(MatrixBlock input, MatrixBlock bias, MatrixBlock outputBlock, int numThreads)`
Performs the operation corresponding to the DML script: ones = matrix(1, rows=1, cols=Hout*Wout) output = input * matrix(bias %*% ones, rows=1, cols=F*Hout*Wout) This operation is often followed by conv2d and hence we have introduced bias_multiply(input, bias) built-in function
`static MatrixBlock`
LibMatrixBincell.`bincellOp(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, BinaryOperator op)`
`static MatrixBlock`
LibMatrixBincell.`bincellOpInPlace(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op)`
NOTE: operations in place always require m1 and m2 to be of equal dimensions defaults to right side operations, updating the m1 matrix with like: m1ret op m2
`static MatrixBlock`
LibMatrixBincell.`bincellOpInPlaceLeft(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op)`
Left side operations, updating the m1 matrix like: m2 op m1ret
`static MatrixBlock`
LibMatrixBincell.`bincellOpInPlaceRight(MatrixBlock m1ret, MatrixBlock m2, BinaryOperator op)`
Right side operations, updating the m1 matrix like: m1ret op m2
`static MatrixBlock`
LibMatrixBincell.`bincellOpScalar(MatrixBlock m1, MatrixBlock ret, ScalarOperator op, int k)`
`MatrixBlock`
MatrixBlock.`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype)`
`MatrixBlock`
MatrixBlock.`chainMatrixMultOperations(MatrixBlock v, MatrixBlock w, MatrixBlock out, MapMultChain.ChainType ctype, int k)`
`static void`
LibMatrixDNN.`channelSums(MatrixBlock input, MatrixBlock outputBlock, int C, int HW)`
Perform channel sum operation
`static void`
MatrixBlock.`checkCMOperations(MatrixBlock mb, CMOperator op)`
`static void`
LibMatrixAppend.`checkDimensionsForAppend(MatrixBlock[] in, boolean cbind, int rlen, int clen)`
`static void`
LibMatrixReorg.`checkRexpand(MatrixBlock in, boolean ignore)`
Quick check if the input is valid for rexpand, this check does not guarantee that the input is valid for rexpand
`CmCovObject`
MatrixBlock.`cmOperations(CMOperator op, MatrixBlock weights)`
`static void`
LibMatrixDNNIm2Col.`col2imOverSingleImage(int outputN, MatrixBlock input, DnnParameters params)`
`static MatrixBlock`
LibCommonsMath.`computeSolve(MatrixBlock in1, MatrixBlock in2)`
Function to solve a given system of equations.
`List<Integer>`
MatrixBlock.`containsVector(MatrixBlock pattern, boolean earlyAbort)`
`static void`
LibMatrixDNN.`conv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, DnnParameters params)`
This method performs convolution (i.e.
`static void`
LibMatrixNative.`conv2d(MatrixBlock input, MatrixBlock filter, MatrixBlock outputBlock, DnnParameters params)`
This method performs convolution (i.e.
`static void`
LibMatrixDNN.`conv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params)`
This method computes the backpropogation errors for previous layer of convolution operation
`static void`
LibMatrixNative.`conv2dBackwardData(MatrixBlock filter, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params)`
This method computes the backpropagation errors for previous layer of convolution operation
`static void`
LibMatrixDNN.`conv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params)`
This method computes the backpropogation errors for filter of convolution operation
`static void`
LibMatrixNative.`conv2dBackwardFilter(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params)`
This method computes the backpropogation errors for filter of convolution operation
`void`
BinaryBlockToTextCellConverter.`convert(MatrixIndexes k1, MatrixBlock v1)`
Before calling convert, please make sure to setBlockSize(blen, blen);
`void`
MatrixBlock.`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.
`static void`
LibMatrixReorg.`copyDenseMtx(MatrixBlock in, MatrixBlock out, int inIdx, int outIdx, int copyLen, boolean isAllocated, boolean copyTotalNonZeros)`
`static void`
LibMatrixReorg.`copyMtx(MatrixBlock in, MatrixBlock out, int inStart, int outStart, int copyLen, boolean isAllocated, boolean copyTotalNonZeros)`
`MatrixBlock`
MatrixBlock.`copyShallow(MatrixBlock that)`
`static long`
LibMatrixMult.`copyUpperToLowerTriangle(MatrixBlock ret)`
`static long`
LibMatrixMult.`copyUpperToLowerTriangleDense(MatrixBlock ret)`
Used for all version of TSMM where the result is known to be symmetric.
`static long`
LibMatrixMult.`copyUpperToLowerTriangleSparse(MatrixBlock ret)`
`static Future<int[]>`
LibMatrixReorg.`countNNZColumns(MatrixBlock in, int k, ExecutorService pool)`
`static List<Future<int[]>>`
LibMatrixReorg.`countNNZColumnsFuture(MatrixBlock in, int k, ExecutorService pool)`
`static int[]`
LibMatrixReorg.`countNnzPerColumn(MatrixBlock in)`
`static int[]`
LibMatrixReorg.`countNnzPerColumn(MatrixBlock in, int rl, int ru)`
`CmCovObject`
MatrixBlock.`covOperations(COVOperator op, MatrixBlock that)`
`CmCovObject`
MatrixBlock.`covOperations(COVOperator op, MatrixBlock that, MatrixBlock weights)`
`static CorrMatrixBlock`
LibMatrixCountDistinct.`createSketch(CountDistinctOperator op, MatrixBlock blkIn)`
`void`
MatrixBlock.`ctableOperations(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`
MatrixBlock.`ctableOperations(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`
MatrixBlock.`ctableOperations(Operator op, MatrixIndexes ix1, double scalarThat, boolean left, int blen, CTableMap resultMap, MatrixBlock resultBlock)`
Specific ctable case of ctable(seq(...),X), where X is the only matrix input.
`void`
MatrixBlock.`ctableOperations(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`
MatrixBlock.`ctableOperations(Operator op, MatrixValue thatVal, MatrixValue that2Val, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
MatrixCell.`ctableOperations(Operator op, double scalarThat, double scalarThat2, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
MatrixCell.`ctableOperations(Operator op, double scalarThat, MatrixValue that2, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
MatrixCell.`ctableOperations(Operator op, MatrixIndexes ix1, double scalarThat, boolean left, int blen, CTableMap resultMap, MatrixBlock resultBlock)`
`void`
MatrixCell.`ctableOperations(Operator op, MatrixValue that, double scalarThat2, boolean ignoreZeros, CTableMap ctableResult, MatrixBlock ctableResultBlock)`
`void`
MatrixCell.`ctableOperations(Operator op, MatrixValue that, MatrixValue that2, CTableMap resultMap, MatrixBlock resultBlock)`
`abstract void`
MatrixValue.`ctableOperations(Operator op, double scalar_that, double scalar_that2, CTableMap resultMap, MatrixBlock resultBlock)`
`abstract void`
MatrixValue.`ctableOperations(Operator op, double scalarThat, MatrixValue that2, CTableMap ctableResult, MatrixBlock ctableResultBlock)`
`abstract void`
MatrixValue.`ctableOperations(Operator op, MatrixIndexes ix1, double scalar_that, boolean left, int blen, CTableMap resultMap, MatrixBlock resultBlock)`
`abstract void`
MatrixValue.`ctableOperations(Operator op, MatrixValue that, double scalar_that2, boolean ignoreZeros, CTableMap resultMap, MatrixBlock resultBlock)`
`abstract void`
MatrixValue.`ctableOperations(Operator op, MatrixValue that, MatrixValue that2, CTableMap resultMap, MatrixBlock resultBlock)`
`final MatrixBlock`
MatrixBlock.`ctableSeqOperations(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)
`MatrixBlock`
MatrixBlock.`ctableSeqOperations(MatrixValue thatMatrix, double thatScalar, MatrixBlock ret, boolean updateClen)`
D = ctable(seq,A,w)
`static MatrixBlock`
LibMatrixAgg.`cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop)`
`static MatrixBlock`
LibMatrixAgg.`cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop, double[] agg)`
`static MatrixBlock`
LibMatrixAgg.`cumaggregateUnaryMatrix(MatrixBlock in, MatrixBlock out, UnaryOperator uop, int k)`
`static void`
LibMatrixDenseToSparse.`denseToSparse(MatrixBlock r, boolean allowCSR)`
Convert the given matrix block to a sparse allocation.
`static void`
LibMatrixDenseToSparse.`denseToSparse(MatrixBlock r, boolean allowCSR, int k)`
`static MatrixBlock`
LibMatrixReorg.`diag(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixMult.`emptyMatrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret)`
`static boolean`
LibMatrixEquals.`equals(MatrixBlock a, MatrixBlock b)`
Analyze if the two matrix blocks are equivalent, this functions even if the underlying allocation and data structure varies.
`static boolean`
LibMatrixEquals.`equals(MatrixBlock a, MatrixBlock b, double eps)`
Analyze if the two matrix blocks are equivalent, this functions even if the underlying allocation and data structure varies.
`final boolean`
MatrixBlock.`equals(MatrixBlock arg0)`
Analyze if the matrixBlocks are equivalent, the comparsion supports if the differnet sides are differently allocated such as sparse and dense.
`static MatrixBlock`
LibMatrixCountDistinct.`estimateDistinctValues(MatrixBlock in, CountDistinctOperator op)`
Public method to count the number of distinct values inside a matrix.
`MatrixBlock`
MatrixBlock.`extractTriangular(MatrixBlock ret, boolean lower, boolean diag, boolean values)`
`static MatrixBlock[]`
LibMatrixFourier.`fft(MatrixBlock re, int threads)`
Function to perform FFT for a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`fft(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform FFT for two given matrices.
`static MatrixBlock[]`
LibMatrixFourier.`fft_linearized(MatrixBlock re, int threads)`
Function to perform FFT for each row of a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`fft_linearized(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform FFT for each row of two given matrices.
`static MatrixBlock`
LibMatrixReorg.`fusedSeqRexpand(int seqHeight, MatrixBlock A, double w)`
The DML code to activate this function:
`static MatrixBlock`
LibMatrixReorg.`fusedSeqRexpand(int seqHeight, MatrixBlock A, double w, MatrixBlock ret, boolean updateClen)`
The DML code to activate this function:
`static MatrixBlock`
LibMatrixReorg.`fusedSeqRexpand(int seqHeight, MatrixBlock A, double w, MatrixBlock ret, boolean updateClen, int k)`
The DML code to activate this function:
`static void`
LibMatrixDatagen.`generateRandomMatrix(MatrixBlock out, RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed)`
Function to generate a matrix of random numbers.
`static void`
LibMatrixDatagen.`generateRandomMatrix(MatrixBlock out, RandomMatrixGenerator rgen, org.apache.commons.math3.random.Well1024a bigrand, long bSeed, int k)`
Function to generate a matrix of random numbers.
`static void`
LibMatrixDatagen.`generateSample(MatrixBlock out, long range, int size, boolean replace, long seed)`
Generates a sample of size `size` from a range of values [1,range].
`static void`
LibMatrixDatagen.`generateSequence(MatrixBlock out, double from, double to, double incr)`
Method to generate a sequence according to the given parameters.
`static void`
LibMatrixDatagen.`genRandomNumbers(boolean invokedFromCP, int rl, int ru, int cl, int cu, MatrixBlock out, RandomMatrixGenerator rgen, long bSeed, long[] seeds)`
`static LibMatrixBincell.BinaryAccessType`
LibMatrixBincell.`getBinaryAccessType(MatrixBlock m1, MatrixBlock m2)`
`static LibMatrixBincell.BinaryAccessType`
LibMatrixBincell.`getBinaryAccessTypeExtended(MatrixBlock m1, MatrixBlock m2)`
`static MatrixBlock`
LibMatrixSketch.`getUniqueValues(MatrixBlock blkIn, Types.Direction dir)`
`static LibMatrixDNNRotate180.Rotate180Worker`
LibMatrixDNNRotate180.Rotate180Worker.`getWorker(MatrixBlock in, MatrixBlock out, DnnParameters params, boolean zeroOutSparseOutput, boolean trans)`
`static void`
LibMatrixAgg.`groupedAggregate(MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, Operator op)`
`static void`
LibMatrixAgg.`groupedAggregate(MatrixBlock groups, MatrixBlock target, MatrixBlock weights, MatrixBlock result, int numGroups, Operator op, int k)`
`static MatrixBlock[]`
LibMatrixFourier.`ifft(MatrixBlock re, int threads)`
Function to perform IFFT for a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`ifft(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform IFFT for two given matrices.
`static MatrixBlock[]`
LibMatrixFourier.`ifft_linearized(MatrixBlock re, int threads)`
Function to perform IFFT for each row of a given matrix.
`static MatrixBlock[]`
LibMatrixFourier.`ifft_linearized(MatrixBlock re, MatrixBlock im, int threads)`
Function to perform IFFT for each row of two given matrices.
`static void`
LibMatrixDNNIm2Col.`im2col(MatrixBlock in, MatrixBlock out, int r, int C, int R, int S, int H, int W, int P, int Q, int stride_h, int stride_w, int pad_h, int pad_w, boolean trans)`
`static void`
LibMatrixDNNIm2Col.`im2col(MatrixBlock in, MatrixBlock out, int r, DnnParameters params, boolean trans)`
`static void`
LibMatrixDNNIm2Col.`im2colSparse(MatrixBlock in, MatrixBlock out, int r, int C, int R, int S, int H, int W, int P, int Q, int stride_h, int stride_w, int pad_h, int pad_w, boolean trans)`
`static boolean`
LibMatrixMult.`isSparseOutputMatrixMult(MatrixBlock m1, MatrixBlock m2)`
`static boolean`
LibMatrixMult.`isSparseOutputTSMM(MatrixBlock m1)`
`static boolean`
LibMatrixMult.`isSparseOutputTSMM(MatrixBlock m1, boolean ultraSparse)`
`static boolean`
LibMatrixMult.`isUltraSparseMatrixMult(MatrixBlock m1, MatrixBlock m2, boolean m1Perm)`
`static void`
LibMatrixBincell.`isValidDimensionsBinary(MatrixBlock m1, MatrixBlock m2)`
`MatrixBlock`
MatrixBlock.`leftIndexingOperations(ScalarObject scalar, int rl, int cl, MatrixBlock ret, MatrixObject.UpdateType update)`
Explicitly allow left indexing for scalars.
`MatrixBlock`
MatrixBlock.`leftIndexingOperations(MatrixBlock rhsMatrix, int rl, int ru, int cl, int cu, MatrixBlock ret, MatrixObject.UpdateType update)`
`final MatrixBlock`
MatrixBlock.`leftIndexingOperations(MatrixBlock rhsMatrix, IndexRange ixrange, MatrixBlock ret, MatrixObject.UpdateType update)`
`static void`
LibMatrixDNNLSTM.`lstmTile(int n, int d, int T, int m, int start, int end, MatrixBlock x, MatrixBlock w, MatrixBlock bias, MatrixBlock out0, MatrixBlock c0, boolean return_sequences, MatrixBlock out, MatrixBlock cout, MatrixBlock cache_out, MatrixBlock cache_c, MatrixBlock cache_ifog)`
`static MatrixBlock`
OperationsOnMatrixValues.`matMult(MatrixBlock value1, MatrixBlock value2, MatrixBlock valueOut, AggregateBinaryOperator op)`
`static MatrixBlock`
OperationsOnMatrixValues.`matMult(MatrixBlock value1, MatrixBlock value2, AggregateBinaryOperator op)`
`static MatrixBlock`
OperationsOnMatrixValues.`matMult(MatrixIndexes indexes1, MatrixBlock value1, MatrixIndexes indexes2, MatrixBlock value2, MatrixIndexes indexesOut, MatrixBlock valueOut, AggregateBinaryOperator op)`
`static MatrixBlock`
LibCommonsMath.`matrixMatrixOperations(MatrixBlock in1, MatrixBlock in2, String opcode)`
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2)`
Performs a matrix multiplication All variants use a IKJ access pattern, and internally use dense output.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, int k)`
Performs a matrix multiplication All variants use a IKJ access pattern, and internally use dense output.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret)`
Performs a matrix multiplication and stores the result in the output matrix.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, boolean fixedRet)`
This method allows one to disabling exam sparsity.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, boolean fixedRet, int k)`
Performs a matrix multiplication and stores the result in the output matrix.
`static MatrixBlock`
LibMatrixMult.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
Performs a multi-threaded matrix multiplication and stores the result in the output matrix.
`static MatrixBlock`
LibMatrixNative.`matrixMult(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
Performs matrix multiplication using native library if BLAS is available or else falls back to Java BLAS.
`static void`
LibMatrixMult.`matrixMultChain(MatrixBlock mX, MatrixBlock mV, MatrixBlock mW, MatrixBlock ret, MapMultChain.ChainType ct)`
Performs a matrix multiplication chain operation of type t(X)%*%(X%*%v) or t(X)%*%(w*(X%*%v)).
`static void`
LibMatrixMult.`matrixMultChain(MatrixBlock mX, MatrixBlock mV, MatrixBlock mW, MatrixBlock ret, MapMultChain.ChainType ct, int k)`
Performs a parallel matrix multiplication chain operation of type t(X)%*%(X%*%v) or t(X)%*%(w*(X%*%v)).
`static MatrixBlock`
LibMatrixMult.`matrixMultNonNative(MatrixBlock m1, MatrixBlock m2, MatrixBlock ret, int k)`
`static void`
LibMatrixMult.`matrixMultPermute(MatrixBlock pm1, MatrixBlock m2, MatrixBlock ret1, MatrixBlock ret2)`
`static void`
LibMatrixMult.`matrixMultPermute(MatrixBlock pm1, MatrixBlock m2, MatrixBlock ret1, MatrixBlock ret2, int k)`
`static MatrixBlock`
LibMatrixMult.`matrixMultTransposeSelf(MatrixBlock m1, MatrixBlock ret, boolean leftTranspose)`
`static void`
LibMatrixMult.`matrixMultTransposeSelf(MatrixBlock m1, MatrixBlock ret, boolean leftTranspose, boolean copyToLowerTriangle)`
`static void`
LibMatrixMult.`matrixMultTransposeSelf(MatrixBlock m1, MatrixBlock ret, boolean leftTranspose, int k)`
TSMM with optional transposed left side or not (Transposed self matrix multiplication)
`static void`
LibMatrixMult.`matrixMultWCeMM(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, double eps, MatrixBlock ret, WeightedCrossEntropy.WCeMMType wt)`
`static void`
LibMatrixMult.`matrixMultWCeMM(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, double eps, MatrixBlock ret, WeightedCrossEntropy.WCeMMType wt, int k)`
`static void`
LibMatrixMult.`matrixMultWDivMM(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, MatrixBlock mX, MatrixBlock ret, WeightedDivMM.WDivMMType wt)`
NOTE: This operation has limited NaN support, which is acceptable because all our sparse-safe operations have only limited NaN support.
`static void`
LibMatrixMult.`matrixMultWDivMM(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, MatrixBlock mX, MatrixBlock ret, WeightedDivMM.WDivMMType wt, int k)`
NOTE: This operation has limited NaN support, which is acceptable because all our sparse-safe operations have only limited NaN support.
`static void`
LibMatrixMult.`matrixMultWSigmoid(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, MatrixBlock ret, WeightedSigmoid.WSigmoidType wt)`
`static void`
LibMatrixMult.`matrixMultWSigmoid(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, MatrixBlock ret, WeightedSigmoid.WSigmoidType wt, int k)`
`static void`
LibMatrixMult.`matrixMultWSLoss(MatrixBlock mX, MatrixBlock mU, MatrixBlock mV, MatrixBlock mW, MatrixBlock ret, WeightedSquaredLoss.WeightsType wt)`
`static void`
LibMatrixMult.`matrixMultWSLoss(MatrixBlock mX, MatrixBlock mU, MatrixBlock mV, MatrixBlock mW, MatrixBlock ret, WeightedSquaredLoss.WeightsType wt, int k)`
`static void`
LibMatrixMult.`matrixMultWuMM(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, MatrixBlock ret, WeightedUnaryMM.WUMMType wt, ValueFunction fn)`
`static void`
LibMatrixMult.`matrixMultWuMM(MatrixBlock mW, MatrixBlock mU, MatrixBlock mV, MatrixBlock ret, WeightedUnaryMM.WUMMType wt, ValueFunction fn, int k)`
`MatrixBlock`
MatrixBlock.`merge(MatrixBlock that, boolean appendOnly)`
`MatrixBlock`
MatrixBlock.`merge(MatrixBlock that, boolean appendOnly, boolean par)`
`MatrixBlock`
MatrixBlock.`merge(MatrixBlock that, boolean appendOnly, boolean par, boolean deep)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in, String opcode, int threads)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in, String opcode, int threads, int num_iterations, double tol)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in, String opcode, int threads, long seed)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in1, MatrixBlock in2, String opcode)`
`static MatrixBlock[]`
LibCommonsMath.`multiReturnOperations(MatrixBlock in1, MatrixBlock in2, String opcode, int threads, long seed)`
`static MatrixBlock`
MatrixBlock.`naryOperations(Operator op, MatrixBlock[] matrices, ScalarObject[] scalars, MatrixBlock ret)`
`static void`
OperationsOnMatrixValues.`performMapGroupedAggregate(Operator op, IndexedMatrixValue inTarget, MatrixBlock groups, int ngroups, int blen, ArrayList<IndexedMatrixValue> outlist)`
`static List`
OperationsOnMatrixValues.`performSlice(IndexRange ixrange, int blen, int iix, int jix, MatrixBlock in)`
`static MatrixBlock`
LibMatrixReorg.`permute(MatrixBlock in, int[] inDims, int[] perm)`
`static MatrixBlock`
LibMatrixReorg.`permute(MatrixBlock in, int[] inDims, int[] perm, int k)`
`static void`
LibMatrixDNN.`pooling(MatrixBlock input, MatrixBlock output, DnnParameters params, LibMatrixDNN.PoolingType poolType)`
`static void`
LibMatrixDNN.`poolingBackward(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, DnnParameters params, boolean performReluBackward, LibMatrixDNN.PoolingType poolType)`
This method computes the backpropogation errors for previous layer of pooling operation
`static void`
LibMatrixDNNIm2Col.`preallocateSparseOutput(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixAgg.`prepareAggregateUnaryOutput(MatrixBlock in, AggregateUnaryOperator op, MatrixValue result, int blen)`
`static MatrixBlock`
LibMatrixMult.`prepMatrixMultTransposeSelfInput(MatrixBlock m1, boolean leftTranspose, boolean par)`
`void`
MatrixBlock.`putInto(MatrixBlock target, int rowOffset, int colOffset, boolean sparseCopyShallow)`
Method for copying this matrix into a target matrix.
`final MatrixBlock`
MatrixBlock.`quaternaryOperations(QuaternaryOperator qop, MatrixBlock um, MatrixBlock vm, MatrixBlock wm, MatrixBlock out)`
`MatrixBlock`
MatrixBlock.`quaternaryOperations(QuaternaryOperator qop, MatrixBlock U, MatrixBlock V, MatrixBlock wm, MatrixBlock out, int k)`
`final MatrixBlock`
MatrixBlock.`rbind(MatrixBlock that)`
`static void`
LibMatrixAgg.`recomputeIndexes(MatrixBlock out, AggregateUnaryOperator op, int blen, MatrixIndexes ix)`
Recompute outputs (e.g., maxindex or minindex) according to block indexes from MR.
`static void`
LibMatrixDNN.`reluBackward(MatrixBlock input, MatrixBlock dout, MatrixBlock outputBlock, int numThreads)`
This method computes the backpropagation errors for previous layer of relu operation
`final MatrixBlock`
MatrixBlock.`removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn)`
`MatrixBlock`
MatrixBlock.`removeEmptyOperations(MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
`static MatrixBlock`
LibMatrixReorg.`removeEmptyRows(MatrixBlock in, MatrixBlock ret, boolean emptyReturn, boolean selectNull, boolean[] flags, int rlen2)`
Remove selected rows, based on the boolean array given.
`static MatrixBlock`
LibMatrixReorg.`reorg(MatrixBlock in, MatrixBlock out, ReorgOperator op)`
`static MatrixBlock`
LibMatrixReorg.`reorgInPlace(MatrixBlock in, ReorgOperator op)`
`static MatrixBlock`
LibMatrixReplace.`replaceOperations(MatrixBlock in, MatrixBlock ret, double pattern, double replacement)`
`static MatrixBlock`
LibMatrixReplace.`replaceOperations(MatrixBlock in, MatrixBlock ret, double pattern, double replacement, int k)`
`static BinaryOperator`
LibMatrixBincell.`replaceOpWithSparseSafeIfApplicable(MatrixBlock m1, MatrixBlock m2, BinaryOperator op)`
`static void`
LibMatrixOuterAgg.`resetOutputMatrix(MatrixIndexes in1Ix, MatrixBlock in1Val, MatrixIndexes outIx, MatrixBlock outVal, AggregateUnaryOperator uaggOp)`
ReSet output matrix
`static MatrixBlock`
LibMatrixReorg.`reshape(MatrixBlock in, int rows, int cols, boolean rowwise)`
CP reshape operation (single input, single output matrix) NOTE: In contrast to R, the rowwise parameter specifies both the read and write order, with row-wise being the default, while R uses always a column-wise read, rowwise specifying the write order and column-wise being the default.
`static MatrixBlock`
LibMatrixReorg.`reshape(MatrixBlock in, MatrixBlock out, int rows, int cols, boolean rowwise)`
CP reshape operation (single input, single output matrix) NOTE: In contrast to R, the rowwise parameter specifies both the read and write order, with row-wise being the default, while R uses always a column-wise read, rowwise specifying the write order and column-wise being the default.
`static MatrixBlock`
LibMatrixReorg.`reshape(MatrixBlock in, MatrixBlock out, int rows, int cols, boolean rowwise, int k)`
CP reshape operation (single input, single output matrix) NOTE: In contrast to R, the rowwise parameter specifies both the read and write order, with row-wise being the default, while R uses always a column-wise read, rowwise specifying the write order and column-wise being the default.
`static MatrixBlock`
LibMatrixReorg.`rev(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixReorg.`rev(MatrixBlock in, MatrixBlock out, int k)`
`static MatrixBlock`
LibMatrixReorg.`rexpand(MatrixBlock in, MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
CP rexpand operation (single input, single output), the classic example of this operation is one hot encoding of a column to multiple columns.
`static MatrixBlock`
LibMatrixReorg.`rexpand(MatrixBlock in, MatrixBlock ret, int max, boolean rows, boolean cast, boolean ignore, int k)`
CP rexpand operation (single input, single output), the classic example of this operation is one hot encoding of a column to multiple columns.
`MatrixBlock`
MatrixBlock.`rexpandOperations(MatrixBlock ret, double max, boolean rows, boolean cast, boolean ignore, int k)`
`static MatrixBlock`
LibMatrixReorg.`rmempty(MatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
CP rmempty operation (single input, single output matrix)
`static MatrixBlock`
LibMatrixReorg.`rmemptyEarlyAbort(MatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
Handle the early-termination cases of removeEmpty that do not require scanning for empty rows/columns.
`static MatrixBlock`
LibMatrixReorg.`rmemptyUnsafe(MatrixBlock in, MatrixBlock ret, boolean rows, boolean emptyReturn, MatrixBlock select)`
`static MatrixBlock`
LibMatrixReorg.`roll(MatrixBlock in, MatrixBlock out, int shift)`
`static MatrixBlock`
LibMatrixReorg.`roll(MatrixBlock input, MatrixBlock output, int shift, int numThreads)`
`static boolean`
LibMatrixAgg.`satisfiesMultiThreadingConstraints(MatrixBlock in, int k)`
`static boolean`
LibMatrixAgg.`satisfiesMultiThreadingConstraints(MatrixBlock in, MatrixBlock out, AggregateUnaryOperator uaop, int k)`
`static boolean`
LibMatrixMult.`satisfiesMultiThreadingConstraints(MatrixBlock m1, boolean checkMem, boolean checkFLOPs, long FPfactor, int k)`
`static boolean`
LibMatrixMult.`satisfiesMultiThreadingConstraints(MatrixBlock m1, int k)`
`static boolean`
LibMatrixMult.`satisfiesMultiThreadingConstraints(MatrixBlock m1, MatrixBlock m2, boolean checkMem, boolean checkFLOPs, long FPfactor, int k)`
`MatrixBlock`
MatrixBlock.`slice(int rl, int ru, int cl, int cu, boolean deep, MatrixBlock ret)`
`final MatrixBlock`
MatrixBlock.`slice(int rl, int ru, int cl, int cu, MatrixBlock ret)`
`final MatrixBlock`
MatrixBlock.`slice(IndexRange ixrange, MatrixBlock ret)`
`static MatrixBlock`
LibMatrixReorg.`sort(MatrixBlock in, MatrixBlock out, int[] by, boolean desc, boolean ixret)`
`static MatrixBlock`
LibMatrixReorg.`sort(MatrixBlock in, MatrixBlock out, int[] by, boolean desc, boolean ixret, int k)`
`final MatrixBlock`
MatrixBlock.`sortOperations(MatrixValue weights, MatrixBlock result)`
`MatrixBlock`
MatrixBlock.`sortOperations(MatrixValue weights, MatrixBlock result, int k)`
`static void`
LibMatrixSparseToDense.`sparseToDense(MatrixBlock r, int k)`
Convert the given matrix block to a Dense allocation.
`static MatrixBlock[]`
LibMatrixSTFT.`stft(MatrixBlock re, int windowSize, int overlap, int threads)`
Function to perform STFT on a given matrices with windowSize and overlap.
`static MatrixBlock[]`
LibMatrixSTFT.`stft(MatrixBlock re, MatrixBlock im, int windowSize, int overlap, int threads)`
Function to perform STFT on two given matrices with windowSize and overlap.
`static void`
LibMatrixTercell.`tercellOp(MatrixBlock m1, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret, TernaryOperator op)`
`final MatrixBlock`
MatrixBlock.`ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3)`
`MatrixBlock`
MatrixBlock.`ternaryOperations(TernaryOperator op, MatrixBlock m2, MatrixBlock m3, MatrixBlock ret)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, int k)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, int k, boolean allowCSR)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, MatrixBlock out)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, MatrixBlock out, int k)`
`static MatrixBlock`
LibMatrixReorg.`transpose(MatrixBlock in, MatrixBlock out, int k, boolean allowCSR)`
`static MatrixBlock`
LibMatrixReorg.`transposeInPlace(MatrixBlock in, int k)`
`static void`
LibMatrixReorg.`transposeInPlaceDenseBrenner(MatrixBlock in, int k)`
Transposes a dense matrix in-place using following cycles based on Brenner's method.
`static boolean`
LibMatrixReorg.`transposeInPlaceTensor(MatrixBlock in, int[] shape, int[] perm)`
Performs prime in-place tensor transposition for arbitrary permutations.
`MatrixBlock`
MatrixBlock.`transposeSelfMatrixMultOperations(MatrixBlock out, MMTSJ.MMTSJType tstype)`
`MatrixBlock`
MatrixBlock.`transposeSelfMatrixMultOperations(MatrixBlock out, MMTSJ.MMTSJType tstype, int k)`
`static void`
LibMatrixNative.`tsmm(MatrixBlock m1, MatrixBlock ret, boolean leftTrans, int k)`
`MatrixBlock`
MatrixBlock.`uaggouterchainOperations(MatrixBlock mbLeft, MatrixBlock mbRight, MatrixBlock mbOut, BinaryOperator bOp, AggregateUnaryOperator uaggOp)`
`static MatrixBlock`
LibCommonsMath.`unaryOperations(MatrixBlock inj, String opcode)`
`static MatrixBlock`
LibMatrixBincell.`uncellOp(MatrixBlock m1, MatrixBlock ret, UnaryOperator op)`
`MatrixBlock`
MatrixBlock.`unionOperations(MatrixBlock m1, MatrixBlock m2)`
Method parameters in org.apache.sysds.runtime.matrix.data with type arguments of type MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
MatrixBlock.`append(List<MatrixBlock> that, MatrixBlock ret, boolean cbind, int k)`
Append that list of matrixblocks together.
Constructors in org.apache.sysds.runtime.matrix.data with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`DnnParameters(int N, int D, int T, int M, MatrixBlock x, MatrixBlock w, MatrixBlock bias, MatrixBlock out0, MatrixBlock c0, boolean return_sequences, int numThreads)`
``
`DnnParameters(int n, int d, int t, int m, MatrixBlock x, MatrixBlock w, MatrixBlock bias, MatrixBlock out0, MatrixBlock c0, MatrixBlock cache_out, MatrixBlock cache_c, MatrixBlock cache_ifog, boolean return_sequences, MatrixBlock dout, MatrixBlock dc, MatrixBlock dx, MatrixBlock dw, MatrixBlock db, MatrixBlock dout0, MatrixBlock dc0, int numThreads)`
``
`MatrixBlock(MatrixBlock that)`
``
`MatrixBlock(MatrixBlock that, boolean sp)`
``
`MatrixBlock(MatrixBlock that, SparseBlock.Type stype, boolean deep)`

## Uses of MatrixBlock in org.apache.sysds.runtime.matrix.data.sketch

Methods in org.apache.sysds.runtime.matrix.data.sketch that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
MatrixSketch.`getValue(MatrixBlock blkIn)`
Get scalar distinct count from an input matrix block.
`MatrixBlock`
MatrixSketch.`getValueFromSketch(CorrMatrixBlock blkIn)`
Obtain matrix distinct count value from estimation Used for estimating distinct in rows or columns.
Methods in org.apache.sysds.runtime.matrix.data.sketch with parameters of type MatrixBlock
Modifier and Type
Method
Description
`CorrMatrixBlock`
MatrixSketch.`create(MatrixBlock blkIn)`
Create an initial sketch of a given block.
`MatrixBlock`
MatrixSketch.`getValue(MatrixBlock blkIn)`
Get scalar distinct count from an input matrix block.

## Uses of MatrixBlock in org.apache.sysds.runtime.matrix.data.sketch.countdistinct

Methods in org.apache.sysds.runtime.matrix.data.sketch.countdistinct that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
CountDistinctFunctionSketch.`getValue(MatrixBlock blkIn)`
`MatrixBlock`
CountDistinctFunctionSketch.`getValueFromSketch(CorrMatrixBlock blkIn)`
Methods in org.apache.sysds.runtime.matrix.data.sketch.countdistinct with parameters of type MatrixBlock
Modifier and Type
Method
Description
`CorrMatrixBlock`
CountDistinctFunctionSketch.`create(MatrixBlock blkIn)`
`MatrixBlock`
CountDistinctFunctionSketch.`getValue(MatrixBlock blkIn)`

## Uses of MatrixBlock in org.apache.sysds.runtime.matrix.data.sketch.countdistinctapprox

Methods in org.apache.sysds.runtime.matrix.data.sketch.countdistinctapprox that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
KMVSketch.`getValue(MatrixBlock blkIn)`
`MatrixBlock`
KMVSketch.`getValueFromSketch(CorrMatrixBlock arg0)`
Methods in org.apache.sysds.runtime.matrix.data.sketch.countdistinctapprox with parameters of type MatrixBlock
Modifier and Type
Method
Description
`CorrMatrixBlock`
KMVSketch.`create(MatrixBlock blkIn)`
`MatrixBlock`
KMVSketch.`getValue(MatrixBlock blkIn)`

## Uses of MatrixBlock in org.apache.sysds.runtime.matrix.operators

Methods in org.apache.sysds.runtime.matrix.operators with parameters of type MatrixBlock
Modifier and Type
Method
Description
`boolean`
BinaryOperator.`isIntroducingZerosLeft(MatrixBlock row)`
Check if the operation returns zeros if the input is contained in row.
`boolean`
BinaryOperator.`isIntroducingZerosRight(MatrixBlock row)`
Check if the operation returns zeros if the input is contained in row.
`boolean`
BinaryOperator.`isRowSafeLeft(MatrixBlock row)`
Check if the operation returns zeros if the input zero.
`boolean`
BinaryOperator.`isRowSafeRight(MatrixBlock row)`
Check if the operation returns zeros if the input zero.

## Uses of MatrixBlock in org.apache.sysds.runtime.transform.decode

Methods in org.apache.sysds.runtime.transform.decode with parameters of type MatrixBlock
Modifier and Type
Method
Description
`abstract FrameBlock`
Decoder.`decode(MatrixBlock in, FrameBlock out)`
Block decode API converting a matrix block into a frame block.
`FrameBlock`
Decoder.`decode(MatrixBlock in, FrameBlock out, int k)`
Block decode API converting a matrix block into a frame block in parallel.
`abstract void`
Decoder.`decode(MatrixBlock in, FrameBlock out, int rl, int ru)`
Block decode row block
`FrameBlock`
DecoderBin.`decode(MatrixBlock in, FrameBlock out)`
`void`
DecoderBin.`decode(MatrixBlock in, FrameBlock out, int rl, int ru)`
`FrameBlock`
DecoderComposite.`decode(MatrixBlock in, FrameBlock out)`
`void`
DecoderComposite.`decode(MatrixBlock in, FrameBlock out, int rl, int ru)`
`FrameBlock`
DecoderDummycode.`decode(MatrixBlock in, FrameBlock out)`
`void`
DecoderDummycode.`decode(MatrixBlock in, FrameBlock out, int rl, int ru)`
`FrameBlock`
DecoderPassThrough.`decode(MatrixBlock in, FrameBlock out)`
`void`
DecoderPassThrough.`decode(MatrixBlock in, FrameBlock out, int rl, int ru)`
`FrameBlock`
DecoderRecode.`decode(MatrixBlock in, FrameBlock out)`
`void`
DecoderRecode.`decode(MatrixBlock in, FrameBlock out, int rl, int ru)`

## Uses of MatrixBlock in org.apache.sysds.runtime.transform.encode

Methods in org.apache.sysds.runtime.transform.encode that return MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
ColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol)`
Apply Functions are only used in Single Threaded or Multi-Threaded Dense context.
`MatrixBlock`
ColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol, int rowStart, int blk)`
`MatrixBlock`
ColumnEncoderComposite.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol, int rowStart, int blk)`
`MatrixBlock`
Encoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol)`
Apply the generated metadata to the FrameBlock and saved the result in out.
`MatrixBlock`
EncoderMVImpute.`apply(FrameBlock in, MatrixBlock out)`
`MatrixBlock`
EncoderOmit.`apply(FrameBlock in, MatrixBlock out)`
`abstract MatrixBlock`
LegacyEncoder.`apply(FrameBlock in, MatrixBlock out)`
Encode input data blockwise according to existing transform meta data (transform apply).
`MatrixBlock`
MultiColumnEncoder.`apply(CacheBlock<?> in)`
`MatrixBlock`
MultiColumnEncoder.`apply(CacheBlock<?> in, int k)`
`MatrixBlock`
MultiColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol)`
`MatrixBlock`
MultiColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol, int k, org.apache.sysds.runtime.transform.encode.MultiColumnEncoder.EncoderMeta encm, long nnz)`
`static MatrixBlock`
CompressedEncode.`encode(MultiColumnEncoder enc, FrameBlock in, int k)`
`MatrixBlock`
EncoderMVImpute.`encode(FrameBlock in, MatrixBlock out)`
`MatrixBlock`
EncoderOmit.`encode(FrameBlock in, MatrixBlock out)`
`abstract MatrixBlock`
LegacyEncoder.`encode(FrameBlock in, MatrixBlock out)`
Block encode: build and apply (transform encode).
`MatrixBlock`
MultiColumnEncoder.`encode(CacheBlock<?> in)`
`MatrixBlock`
MultiColumnEncoder.`encode(CacheBlock<?> in, boolean compressedOut)`
`MatrixBlock`
MultiColumnEncoder.`encode(CacheBlock<?> in, int k)`
`MatrixBlock`
MultiColumnEncoder.`encode(CacheBlock<?> in, int k, boolean compressedOut)`
`MatrixBlock`
ColumnEncoder.`getColMapping(FrameBlock meta)`
Obtain the column mapping of encoded frames based on the passed meta data frame.
`MatrixBlock`
LegacyEncoder.`getColMapping(FrameBlock meta, MatrixBlock out)`
Obtain the column mapping of encoded frames based on the passed meta data frame.
`MatrixBlock`
MultiColumnEncoder.`getColMapping(FrameBlock meta)`
Obtain the column mapping of encoded frames based on the passed meta data frame.
Methods in org.apache.sysds.runtime.transform.encode with parameters of type MatrixBlock
Modifier and Type
Method
Description
`MatrixBlock`
ColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol)`
Apply Functions are only used in Single Threaded or Multi-Threaded Dense context.
`MatrixBlock`
ColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol, int rowStart, int blk)`
`MatrixBlock`
ColumnEncoderComposite.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol, int rowStart, int blk)`
`MatrixBlock`
Encoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol)`
Apply the generated metadata to the FrameBlock and saved the result in out.
`MatrixBlock`
EncoderMVImpute.`apply(FrameBlock in, MatrixBlock out)`
`MatrixBlock`
EncoderOmit.`apply(FrameBlock in, MatrixBlock out)`
`abstract MatrixBlock`
LegacyEncoder.`apply(FrameBlock in, MatrixBlock out)`
Encode input data blockwise according to existing transform meta data (transform apply).
`MatrixBlock`
MultiColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol)`
`MatrixBlock`
MultiColumnEncoder.`apply(CacheBlock<?> in, MatrixBlock out, int outputCol, int k, org.apache.sysds.runtime.transform.encode.MultiColumnEncoder.EncoderMeta encm, long nnz)`
`void`
ColumnEncoderUDF.`applyDense(CacheBlock<?> in, MatrixBlock out, int outputCol, int rowStart, int blk)`
`void`
ColumnEncoderWordEmbedding.`applyDense(CacheBlock<?> in, MatrixBlock out, int outputCol, int rowStart, int blk)`
`static MultiColumnEncoder`
EncoderFactory.`createEncoder(String spec, String[] colnames, int clen, FrameBlock meta, MatrixBlock embeddings)`
`static MultiColumnEncoder`
EncoderFactory.`createEncoder(String spec, String[] colnames, int clen, FrameBlock meta, MatrixBlock embeddings, int minCol, int maxCol)`
`static MultiColumnEncoder`
EncoderFactory.`createEncoder(String spec, String[] colnames, Types.ValueType[] schema, int clen, FrameBlock meta, MatrixBlock embeddings)`
`static MultiColumnEncoder`
EncoderFactory.`createEncoder(String spec, String[] colnames, Types.ValueType[] schema, FrameBlock meta, MatrixBlock embeddings)`
`MatrixBlock`
EncoderMVImpute.`encode(FrameBlock in, MatrixBlock out)`
`MatrixBlock`
EncoderOmit.`encode(FrameBlock in, MatrixBlock out)`
`abstract MatrixBlock`
LegacyEncoder.`encode(FrameBlock in, MatrixBlock out)`
Block encode: build and apply (transform encode).
`List<DependencyTask<?>>`
ColumnEncoder.`getApplyTasks(CacheBlock<?> in, MatrixBlock out, int outputCol, int[] sparseRowPointerOffsets)`
`List<DependencyTask<?>>`
ColumnEncoderComposite.`getApplyTasks(CacheBlock<?> in, MatrixBlock out, int outputCol, int[] sparseRowPointerOffsets)`
`MatrixBlock`
LegacyEncoder.`getColMapping(FrameBlock meta, MatrixBlock out)`
Obtain the column mapping of encoded frames based on the passed meta data frame.
`void`
ColumnEncoder.`initEmbeddings(MatrixBlock embeddings)`
`void`
ColumnEncoderComposite.`initEmbeddings(MatrixBlock embeddings)`
`void`
ColumnEncoderWordEmbedding.`initEmbeddings(MatrixBlock embeddings)`
`void`
MultiColumnEncoder.`initEmbeddings(MatrixBlock embeddings)`
Constructors in org.apache.sysds.runtime.transform.encode with parameters of type MatrixBlock
Modifier
Constructor
Description
``
`FeatureHashSparseApplyTask(ColumnEncoderFeatureHash encoder, CacheBlock<?> input, MatrixBlock out, int outputCol)`
``
`FeatureHashSparseApplyTask(ColumnEncoderFeatureHash encoder, CacheBlock<?> input, MatrixBlock out, int outputCol, int startRow, int blk)`

## Uses of MatrixBlock in org.apache.sysds.runtime.util

Methods in org.apache.sysds.runtime.util that return MatrixBlock
Modifier and Type
Method
Description
`static MatrixBlock`
Py4jConverterUtils.`allocateDenseOrSparse(int rlen, int clen, boolean isSparse)`
`static MatrixBlock`
Py4jConverterUtils.`allocateDenseOrSparse(long rlen, long clen, boolean isSparse)`
`static MatrixBlock`
Py4jConverterUtils.`convertPy4JArrayToMB(byte[] data, int rlen, int clen)`
`static MatrixBlock`
Py4jConverterUtils.`convertPy4JArrayToMB(byte[] data, int rlen, int clen, boolean isSparse, Types.ValueType valueType)`
`static MatrixBlock`
Py4jConverterUtils.`convertPy4JArrayToMB(byte[] data, int rlen, int clen, Types.ValueType valueType)`
`static MatrixBlock`
Py4jConverterUtils.`convertSciPyCOOToMB(byte[] data, byte[] row, byte[] col, int rlen, int clen, int nnz)`
`static MatrixBlock`
Py4jConverterUtils.`convertSciPyCSRToMB(byte[] data, byte[] indices, byte[] indptr, int rlen, int clen, int nnz)`
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(double[][] data)`
Creates a dense Matrix Block and copies the given double matrix into it.
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(double[] data, boolean columnVector)`
Creates a dense Matrix Block and copies the given double vector into it.
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(int[][] data)`
Converts an Integer matrix to an MatrixBlock
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(HashMap<MatrixIndexes,Double> map)`
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(HashMap<MatrixIndexes,Double> map, int rlen, int clen)`
NOTE: this method also ensures the specified matrix dimensions
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(org.apache.commons.math3.linear.RealMatrix rm)`
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(FrameBlock frame)`
Converts a frame block with arbitrary schema into a matrix block.
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(CTableMap map)`
`static MatrixBlock`
DataConverter.`convertToMatrixBlock(CTableMap map, int rlen, int clen)`
NOTE: this method also ensures the specified matrix dimensions
`static MatrixBlock[]`
DataConverter.`convertToMatrixBlockPartitions(MatrixBlock mb, boolean colwise)`
`static MatrixBlock`
LocalFileUtils.`readMatrixBlockFromLocal(String fname)`
Reads a matrix block from local file system.
`static MatrixBlock`
LocalFileUtils.`readMatrixBlockFromLocal(String fname, MatrixBlock reuse)`
Reads a matrix block from local file system.
`static MatrixBlock`
LocalFileUtils.`readMatrixBlockFromStream(InputStream is)`
Reads a matrix block from an input stream, using a fused buffered reader with special support for matrix blocks.
`static MatrixBlock`
DataConverter.`readMatrixFromHDFS(String dir, Types.FileFormat fmt, long rlen, long clen, int blen)`
`static MatrixBlock`
DataConverter.`readMatrixFromHDFS(String dir, Types.FileFormat fmt, long rlen, long clen, int blen, long expectedNnz)`
`static MatrixBlock`
DataConverter.`readMatrixFromHDFS(String dir, Types.FileFormat fmt, long rlen, long clen, int blen, long expectedNnz, FileFormatProperties formatProperties)`
`static MatrixBlock`
DataConverter.`readMatrixFromHDFS(ReadProperties prop)`
Core method for reading matrices in format textcell, matrixmarket, binarycell, or binaryblock from HDFS into main memory.
Methods in org.apache.sysds.runtime.util with parameters of type MatrixBlock
Modifier and Type
Method
Description
`static byte[]`
Py4jConverterUtils.`convertMBtoPy4JDenseArr(MatrixBlock mb)`
`static org.apache.commons.math3.linear.Array2DRowRealMatrix`
DataConverter.`convertToArray2DRowRealMatrix(MatrixBlock mb)`
Helper method that converts SystemDS matrix variable (`varname`) into a Array2DRowRealMatrix format, which is useful in invoking Apache CommonsMath.
`static org.apache.commons.math3.linear.BlockRealMatrix`
DataConverter.`convertToBlockRealMatrix(MatrixBlock mb)`
`static boolean[]`
DataConverter.`convertToBooleanVector(MatrixBlock mb)`
`static DenseBlock`
DataConverter.`convertToDenseBlock(MatrixBlock mb)`
`static DenseBlock`
DataConverter.`convertToDenseBlock(MatrixBlock mb, boolean deep)`
`static List<Double>`
DataConverter.`convertToDoubleList(MatrixBlock mb)`
`static double[][]`
DataConverter.`convertToDoubleMatrix(MatrixBlock mb)`
Creates a two-dimensional double matrix of the input matrix block.
`static double[]`
DataConverter.`convertToDoubleVector(MatrixBlock mb)`
`static double[]`
DataConverter.`convertToDoubleVector(MatrixBlock mb, boolean deep)`
`static double[]`
DataConverter.`convertToDoubleVector(MatrixBlock mb, boolean deep, boolean allowNull)`
`static FrameBlock`
DataConverter.`convertToFrameBlock(MatrixBlock mb)`
Converts a matrix block into a frame block of value type double.
`static FrameBlock`
DataConverter.`convertToFrameBlock(MatrixBlock mb, int k)`
Converts a matrix block into a frame block of value type double.
`static FrameBlock`
DataConverter.`convertToFrameBlock(MatrixBlock mb, Types.ValueType vt)`
Converts a matrix block into a frame block of value type given.
`static FrameBlock`
DataConverter.`convertToFrameBlock(MatrixBlock mb, Types.ValueType[] schema)`
Converts a matrix block into a frame block of with the given schema
`static FrameBlock`
DataConverter.`convertToFrameBlock(MatrixBlock mb, Types.ValueType[] schema, int k)`
Converts a matrix block into a frame block of with the given schema
`static FrameBlock`
DataConverter.`convertToFrameBlock(MatrixBlock mb, Types.ValueType vt, int k)`
Converts a matrix block into a frame block of a given value type.
`static int[]`
DataConverter.`convertToIntVector(MatrixBlock mb)`
`static long[]`
DataConverter.`convertToLongVector(MatrixBlock mb)`
`static MatrixBlock[]`
DataConverter.`convertToMatrixBlockPartitions(MatrixBlock mb, boolean colwise)`
`static TensorBlock`
DataConverter.`convertToTensorBlock(MatrixBlock mb, Types.ValueType vt, boolean toBasicTensor)`
`static int[]`
DataConverter.`convertVectorToIndexList(MatrixBlock mb)`
`static void`
DataConverter.`copyToDoubleVector(MatrixBlock mb, double[] dest, int destPos)`
`static IndexedMatrixValue`
UtilFunctions.`createIndexedMatrixBlock(MatrixBlock mb, DataCharacteristics mc, long ix)`
`static void`
DnnUtils.`fillBias(MatrixBlock bias, double[] outputArray, int src_rl, int src_ru, int N, int K, int PQ)`
`static boolean`
SortUtils.`isSorted(MatrixBlock in)`
`static MatrixBlock`
LocalFileUtils.`readMatrixBlockFromLocal(String fname, MatrixBlock reuse)`
Reads a matrix block from local file system.
`static String`
DataConverter.`toString(MatrixBlock mb)`
`static String`
DataConverter.`toString(MatrixBlock mb, boolean sparse, String separator, String lineseparator, int rowsToPrint, int colsToPrint, int decimal)`
Returns a string representation of a matrix
`static void`
LocalFileUtils.`writeMatrixBlockToLocal(String fname, MatrixBlock mb)`
Writes a matrix block to local file system.
`static void`
DataConverter.`writeMatrixToHDFS(MatrixBlock mat, String dir, Types.FileFormat fmt, DataCharacteristics dc)`
`static void`
DataConverter.`writeMatrixToHDFS(MatrixBlock mat, String dir, Types.FileFormat fmt, DataCharacteristics dc, int replication, FileFormatProperties formatProperties)`
`static void`
DataConverter.`writeMatrixToHDFS(MatrixBlock mat, String dir, Types.FileFormat fmt, DataCharacteristics dc, int replication, FileFormatProperties formatProperties, boolean diag)`
`static long`
UnixPipeUtils.`writeNumpyArrayInBatches(BufferedOutputStream out, int id, int batchSize, int numElem, Types.ValueType type, MatrixBlock mb)`
Symmetric with readNumpyArrayInBatches — writes data in batches with handshake.