# Uses of Class
org.apache.sysds.runtime.compress.colgroup.AColGroup

Packages that use AColGroup
Package
Description
org.apache.sysds.runtime.compress
org.apache.sysds.runtime.compress.colgroup
org.apache.sysds.runtime.compress.colgroup.indexes
org.apache.sysds.runtime.compress.colgroup.scheme
org.apache.sysds.runtime.compress.cost
org.apache.sysds.runtime.compress.lib

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

Methods in org.apache.sysds.runtime.compress that return AColGroup
Modifier and Type
Method
Description
`AColGroup`
CompressedMatrixBlock.`getColGroupForColumn(int id)`
Get the column group allocated and associated with a specific column Id; There is some search involved in this since we do not know where to look for the column and which Column group contains the value.
Methods in org.apache.sysds.runtime.compress that return types with arguments of type AColGroup
Modifier and Type
Method
Description
`List<AColGroup>`
CompressedMatrixBlock.`getColGroups()`
Get the column groups of this CompressedMatrixBlock
Methods in org.apache.sysds.runtime.compress with parameters of type AColGroup
Modifier and Type
Method
Description
`void`
CompressedMatrixBlock.`allocateColGroup(AColGroup cg)`
Allocate the given column group and remove all references to old column groups.
Method parameters in org.apache.sysds.runtime.compress with type arguments of type AColGroup
Modifier and Type
Method
Description
`void`
CompressedMatrixBlock.`allocateColGroupList(List<AColGroup> colGroups)`
Replace the column groups in this CompressedMatrixBlock with the given column groups
Constructor parameters in org.apache.sysds.runtime.compress with type arguments of type AColGroup
Modifier
Constructor
Description
``
`CompressedMatrixBlock(int rl, int cl, long nnz, boolean overlapping, List<AColGroup> groups)`
Direct constructor with everything.

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

Subclasses of AColGroup in org.apache.sysds.runtime.compress.colgroup
Modifier and Type
Class
Description
`class`
`AColGroupCompressed`
Base class for column groups encoded Encoded in a compressed manner.
`class`
`AColGroupOffset`
Base class for column groups encoded with various types of bitmap encoding.
`class`
`AColGroupValue`
`class`
`ADictBasedColGroup`
`class`
`AMorphingMMColGroup`
Abstract class for column group types that do not perform matrix Multiplication, and decompression for performance reasons but instead transforms into another type of column group type to perform that operation.
`class`
`APreAgg`
Abstract class for all the column groups that use preAggregation for Left matrix multiplications.
`class`
`ASDC`
Column group that sparsely encodes the dictionary values.
`class`
`ASDCZero`
`class`
`ColGroupConst`
`class`
`ColGroupDDC`
Class to encapsulate information about a column group that is encoded with dense dictionary encoding (DDC).
`class`
`ColGroupDDCFOR`
Class to encapsulate information about a column group that is encoded with dense dictionary encoding (DDC).
`class`
`ColGroupDDCLZW`
Class to encapsulate information about a column group that is encoded with dense dictionary encoding (DDC) whose mapping vector is additionally lzw compressed.
`class`
`ColGroupDeltaDDC`
Class to encapsulate information about a column group that is first delta encoded then encoded with dense dictionary encoding (DeltaDDC).
`class`
`ColGroupEmpty`
`class`
`ColGroupLinearFunctional`
`class`
`ColGroupOLE`
Class to encapsulate information about a column group that is encoded with simple lists of offsets for each set of distinct values.
`class`
`ColGroupRLE`
A group of columns compressed with a single run-length encoded bitmap.
`class`
`ColGroupSDC`
Column group that sparsely encodes the dictionary values.
`class`
`ColGroupSDCFOR`
ColGroup for Patched Frame Of Reference.
`class`
`ColGroupSDCSingle`
Column group that sparsely encodes the dictionary values.
`class`
`ColGroupSDCSingleZeros`
Column group that sparsely encodes the dictionary values.
`class`
`ColGroupSDCZeros`
Column group that sparsely encodes the dictionary values.
`class`
`ColGroupUncompressed`
Column group type for columns that are stored as dense arrays of doubles.
`class`
`ColGroupUncompressedArray`
Special sideways compressed column group not supposed to be used outside of the compressed transform encode.
Methods in org.apache.sysds.runtime.compress.colgroup that return AColGroup
Modifier and Type
Method
Description
`AColGroup`
AColGroup.`addVector(double[] v)`
Short hand add operator call on column group to add a row vector to the column group
`abstract AColGroup`
AColGroup.`append(AColGroup g)`
Append the other column group to this column group.
`AColGroup`
ColGroupConst.`append(AColGroup g)`
`AColGroup`
ColGroupDDC.`append(AColGroup g)`
`AColGroup`
ColGroupDDCFOR.`append(AColGroup g)`
`AColGroup`
ColGroupDDCLZW.`append(AColGroup g)`
`AColGroup`
ColGroupDeltaDDC.`append(AColGroup g)`
`AColGroup`
ColGroupEmpty.`append(AColGroup g)`
`AColGroup`
ColGroupLinearFunctional.`append(AColGroup g)`
`AColGroup`
ColGroupOLE.`append(AColGroup g)`
`AColGroup`
ColGroupRLE.`append(AColGroup g)`
`AColGroup`
ColGroupSDC.`append(AColGroup g)`
`AColGroup`
ColGroupSDCFOR.`append(AColGroup g)`
`AColGroup`
ColGroupSDCSingle.`append(AColGroup g)`
`AColGroup`
ColGroupSDCSingleZeros.`append(AColGroup g)`
`AColGroup`
ColGroupSDCZeros.`append(AColGroup g)`
`AColGroup`
ColGroupUncompressed.`append(AColGroup g)`
`AColGroup`
ColGroupUncompressedArray.`append(AColGroup g)`
`static AColGroup`
AColGroup.`appendN(AColGroup[] groups, int blen, int rlen)`
Append all column groups in the list provided together in one go allocating the output once.
`AColGroup`
ColGroupConst.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupDDC.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupDDCFOR.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupDeltaDDC.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupEmpty.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupLinearFunctional.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupOLE.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupRLE.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDC.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCFOR.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCSingle.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCSingleZeros.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCZeros.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupUncompressed.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`abstract AColGroup`
AColGroup.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
Perform a binary row operation.
`AColGroup`
ColGroupConst.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupDDC.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupDDCFOR.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupDDCLZW.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupEmpty.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupLinearFunctional.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupOLE.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupRLE.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDC.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCFOR.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCSingle.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCSingleZeros.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCZeros.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupUncompressed.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupUncompressedArray.`binaryRowOpLeft(BinaryOperator op, double[] v, boolean isRowSafe)`
`abstract AColGroup`
AColGroup.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
Perform a binary row operation.
`AColGroup`
ColGroupConst.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupDDC.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupDDCFOR.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupDDCLZW.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupEmpty.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupLinearFunctional.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupOLE.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupRLE.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDC.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCFOR.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCSingle.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCSingleZeros.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupSDCZeros.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupUncompressed.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
ColGroupUncompressedArray.`binaryRowOpRight(BinaryOperator op, double[] v, boolean isRowSafe)`
`AColGroup`
AColGroup.`combine(AColGroup other, int nRow)`
Combine this column group with another
`AColGroup`
AColGroup.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
C bind the list of column groups with this column group.
`AColGroup`
AColGroup.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
C bind the given column group to this.
`AColGroup`
ColGroupConst.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupConst.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupDDCFOR.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupDDCFOR.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupEmpty.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupEmpty.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupUncompressed.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupUncompressed.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupDDCLZW.`convertToDDC()`
Converts the current ColGroupDDCLZW instance to a ColGroupDDC instance.
`AColGroup`
ColGroupDDC.`convertToDDCLZW()`
`AColGroup`
ColGroupDDC.`convertToDeltaDDC()`
`abstract AColGroup`
AColGroup.`copyAndSet(IColIndex colIndexes)`
Copy the content of the column group with pointers to the previous content but with new column given Note this method does not verify if the colIndexes specified are valid and correct dimensions for the underlying column groups.
`final AColGroup`
ADictBasedColGroup.`copyAndSet(IDictionary newDictionary)`
This method copies the column group and sets the dictionary to another dictionary.
`final AColGroup`
ADictBasedColGroup.`copyAndSet(IColIndex colIndexes)`
`AColGroup`
ColGroupEmpty.`copyAndSet(IColIndex colIndexes)`
`AColGroup`
ColGroupLinearFunctional.`copyAndSet(IColIndex colIndexes)`
`AColGroup`
ColGroupUncompressed.`copyAndSet(IColIndex colIndexes)`
`AColGroup`
ColGroupUncompressedArray.`copyAndSet(IColIndex colIndexes)`
`static AColGroup`
ColGroupConst.`create(double[] values)`
Generate a constant column group.
`static AColGroup`
ColGroupConst.`create(int numCols, double value)`
Generate a constant column group.
`static AColGroup`
ColGroupConst.`create(int numCols, IDictionary dict)`
Generate a constant column group.
`static AColGroup`
ColGroupConst.`create(IColIndex cols, double value)`
Generate a constant column group.
`static AColGroup`
ColGroupConst.`create(IColIndex cols, double[] values)`
Generate a constant column group.
`static AColGroup`
ColGroupConst.`create(IColIndex colIndices, IDictionary dict)`
Create constructor for a ColGroup Const this constructor ensures that if the dictionary input is empty an Empty column group is constructed.
`static AColGroup`
ColGroupDDC.`create(IColIndex colIndexes, IDictionary dict, AMapToData data, int[] cachedCounts)`
`static AColGroup`
ColGroupDDCFOR.`create(IColIndex colIndexes, IDictionary dict, AMapToData data, int[] cachedCounts, double[] reference)`
`static AColGroup`
ColGroupDDCLZW.`create(IColIndex colIndexes, IDictionary dict, AMapToData data, int[] cachedCounts)`
`static AColGroup`
ColGroupDeltaDDC.`create(IColIndex colIndexes, IDictionary dict, AMapToData data, int[] cachedCounts)`
`static AColGroup`
ColGroupLinearFunctional.`create(IColIndex colIndices, double[] coefficents, int numRows)`
Generate a linear functional column group.
`static AColGroup`
ColGroupSDC.`create(IColIndex colIndices, int numRows, IDictionary dict, double[] defaultTuple, AOffset offsets, AMapToData data, int[] cachedCounts)`
`static AColGroup`
ColGroupSDCFOR.`create(IColIndex colIndexes, int numRows, IDictionary dict, AOffset offsets, AMapToData data, int[] cachedCounts, double[] reference)`
`static AColGroup`
ColGroupSDCSingle.`create(IColIndex colIndexes, int numRows, IDictionary dict, double[] defaultTuple, AOffset offsets, int[] cachedCounts)`
`static AColGroup`
ColGroupSDCSingleZeros.`create(IColIndex colIndices, int numRows, IDictionary dict, AOffset offsets, int[] cachedCounts)`
`static AColGroup`
ColGroupSDCZeros.`create(IColIndex colIndices, int numRows, IDictionary dict, AOffset offsets, AMapToData data, int[] cachedCounts)`
`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.
`abstract AColGroup`
AMorphingMMColGroup.`extractCommon(double[] constV)`
extract common value from group and return non morphing group
`AColGroup`
ColGroupDDCFOR.`extractCommon(double[] constV)`
`AColGroup`
ColGroupSDC.`extractCommon(double[] constV)`
`AColGroup`
ColGroupSDCFOR.`extractCommon(double[] constV)`
`AColGroup`
ColGroupSDCSingle.`extractCommon(double[] constV)`
`AColGroup`
IFrameOfReferenceGroup.`extractCommon(double[] constV)`
extract common value from group and return non morphing group
`AColGroup`
AColGroup.`morph(AColGroup.CompressionType ct, int nRow)`
Recompress this column group into a new column group of the given type.
`AColGroup`
ASDC.`morph(AColGroup.CompressionType ct, int nRow)`
`AColGroup`
ASDCZero.`morph(AColGroup.CompressionType ct, int nRow)`
`AColGroup`
ColGroupDDC.`morph(AColGroup.CompressionType ct, int nRow)`
`AColGroup`
ColGroupSDC.`morph(AColGroup.CompressionType ct, int nRow)`
`AColGroup`
ColGroupSDCZeros.`morph(AColGroup.CompressionType ct, int nRow)`
`AColGroup`
ColGroupUncompressed.`morph(AColGroup.CompressionType ct, int nRow)`
`static AColGroup`
ColGroupIO.`readColGroup(DataInput in, int nRows)`
`abstract AColGroup`
AColGroup.`recompress()`
Recompress this column group into a new column group.
`AColGroup`
ColGroupConst.`recompress()`
`AColGroup`
ColGroupDDC.`recompress()`
`AColGroup`
ColGroupDDCFOR.`recompress()`
`AColGroup`
ColGroupDDCLZW.`recompress()`
`AColGroup`
ColGroupEmpty.`recompress()`
`AColGroup`
ColGroupLinearFunctional.`recompress()`
`AColGroup`
ColGroupOLE.`recompress()`
`AColGroup`
ColGroupRLE.`recompress()`
`AColGroup`
ColGroupSDC.`recompress()`
`AColGroup`
ColGroupSDCFOR.`recompress()`
`AColGroup`
ColGroupSDCSingle.`recompress()`
`AColGroup`
ColGroupSDCSingleZeros.`recompress()`
`AColGroup`
ColGroupSDCZeros.`recompress()`
`AColGroup`
ColGroupUncompressed.`recompress()`
`AColGroup`
ColGroupUncompressedArray.`recompress()`
`abstract AColGroup`
AColGroup.`reduceCols()`
Perform row sum on the internal dictionaries, and return the same index structure.
`AColGroup`
ADictBasedColGroup.`reduceCols()`
`AColGroup`
ColGroupEmpty.`reduceCols()`
`AColGroup`
ColGroupLinearFunctional.`reduceCols()`
`AColGroup`
ColGroupUncompressed.`reduceCols()`
`AColGroup`
ColGroupUncompressedArray.`reduceCols()`
`AColGroup`
AColGroup.`removeEmptyCols(boolean[] selectV)`
Return a new column group containing only the selected columns in the given boolean vector.
`abstract AColGroup`
AColGroup.`removeEmptyRows(boolean[] selectV, int rOut)`
Return a new column group containing only the selected rows in the given boolean vector.
`AColGroup`
ColGroupConst.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupDDC.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupDDCFOR.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupDDCLZW.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupEmpty.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupLinearFunctional.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupOLE.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupRLE.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupSDC.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupSDCFOR.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupSDCSingle.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupSDCSingleZeros.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupSDCZeros.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupUncompressed.`removeEmptyRows(boolean[] selectV, int rOut)`
`AColGroup`
ColGroupUncompressedArray.`removeEmptyRows(boolean[] selectV, int rOut)`
`abstract AColGroup`
AColGroup.`replace(double pattern, double replace)`
Make a copy of the column group values, and replace all values that match pattern with replacement value.
`AColGroup`
AColGroupValue.`replace(double pattern, double replace)`
`AColGroup`
ColGroupConst.`replace(double pattern, double replace)`
`AColGroup`
ColGroupDDCFOR.`replace(double pattern, double replace)`
`AColGroup`
ColGroupEmpty.`replace(double pattern, double replace)`
`AColGroup`
ColGroupLinearFunctional.`replace(double pattern, double replace)`
`AColGroup`
ColGroupSDC.`replace(double pattern, double replace)`
`AColGroup`
ColGroupSDCFOR.`replace(double pattern, double replace)`
`AColGroup`
ColGroupSDCSingle.`replace(double pattern, double replace)`
`AColGroup`
ColGroupSDCSingleZeros.`replace(double pattern, double replace)`
`AColGroup`
ColGroupSDCZeros.`replace(double pattern, double replace)`
`AColGroup`
ColGroupUncompressed.`replace(double pattern, double replace)`
`AColGroup`
ColGroupUncompressedArray.`replace(double pattern, double replace)`
`abstract AColGroup`
AColGroup.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
Expand the column group to multiple columns.
`AColGroup`
AColGroupValue.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupConst.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupDDCFOR.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupEmpty.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupLinearFunctional.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupSDC.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupSDCFOR.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupSDCSingle.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupUncompressed.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`AColGroup`
ColGroupUncompressedArray.`rexpandCols(int max, boolean ignore, boolean cast, int nRows)`
`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)`
`abstract AColGroup`
AColGroup.`scalarOperation(ScalarOperator op)`
Perform the specified scalar operation directly on the compressed column group, without decompressing individual cells if possible.
`AColGroup`
ColGroupConst.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupDDC.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupDDCFOR.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupDDCLZW.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupDeltaDDC.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupEmpty.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupLinearFunctional.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupOLE.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupRLE.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupSDC.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupSDCFOR.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupSDCSingle.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupSDCSingleZeros.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupSDCZeros.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupUncompressed.`scalarOperation(ScalarOperator op)`
`AColGroup`
ColGroupUncompressedArray.`scalarOperation(ScalarOperator op)`
`final AColGroup`
AColGroup.`shiftColIndices(int offset)`
Shift all column indexes contained by an offset.
`final AColGroup`
AColGroup.`sliceColumn(int col)`
Slice out a single column from the column group.
`final AColGroup`
AColGroup.`sliceColumns(int cl, int cu)`
Slice out the columns within the range of cl and cu to remove the dictionary values related to these columns.
`abstract AColGroup`
AColGroup.`sliceRows(int rl, int ru)`
Slice range of rows out of the column group and return a new column group only containing the row segment.
`AColGroup`
ColGroupConst.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupDDC.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupDDCFOR.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupDDCLZW.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupDeltaDDC.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupEmpty.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupLinearFunctional.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupOLE.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupRLE.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupSDC.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupSDCFOR.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupSDCSingle.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupSDCSingleZeros.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupSDCZeros.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupUncompressed.`sliceRows(int rl, int ru)`
`AColGroup`
ColGroupUncompressedArray.`sliceRows(int rl, int ru)`
`abstract AColGroup`
AColGroup.`sort()`
Sort the values of the column group according to double comparison operations and return as another compressed group.
`AColGroup`
ColGroupConst.`sort()`
`AColGroup`
ColGroupDDC.`sort()`
`AColGroup`
ColGroupDDCFOR.`sort()`
`AColGroup`
ColGroupDDCLZW.`sort()`
`AColGroup`
ColGroupEmpty.`sort()`
`AColGroup`
ColGroupLinearFunctional.`sort()`
`AColGroup`
ColGroupOLE.`sort()`
`AColGroup`
ColGroupRLE.`sort()`
`AColGroup`
ColGroupSDC.`sort()`
`AColGroup`
ColGroupSDCFOR.`sort()`
`AColGroup`
ColGroupSDCSingle.`sort()`
`AColGroup`
ColGroupSDCSingleZeros.`sort()`
`AColGroup`
ColGroupSDCZeros.`sort()`
`AColGroup`
ColGroupUncompressed.`sort()`
`AColGroup`
ColGroupUncompressedArray.`sort()`
`AColGroup`
AColGroup.`sortColumnIndexes()`
`AColGroup`
ColGroupDDC.`sparsifyFOR()`
`static AColGroup`
ColGroupDDCFOR.`sparsifyFOR(ColGroupDDC g)`
`AColGroup`
ColGroupSDC.`sparsifyFOR()`
`static AColGroup`
ColGroupSDCFOR.`sparsifyFOR(ColGroupSDC g)`
`abstract AColGroup[]`
AColGroup.`splitReshape(int multiplier, int nRow, int nColOrg)`
This method returns a list of column groups that are naive splits of this column group as if it is reshaped.
`AColGroup[]`
ColGroupConst.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupDDC.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupDDCFOR.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupDDCLZW.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupEmpty.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupLinearFunctional.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupOLE.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupRLE.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupSDC.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupSDCFOR.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupSDCSingle.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupSDCSingleZeros.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupSDCZeros.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupUncompressed.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
ColGroupUncompressedArray.`splitReshape(int multiplier, int nRow, int nColOrg)`
`AColGroup[]`
AColGroup.`splitReshapePushDown(int multiplier, int nRow, int nColOrg, ExecutorService pool)`
This method returns a list of column groups that are naive splits of this column group as if it is reshaped.
`AColGroup[]`
ColGroupDDC.`splitReshapePushDown(int multiplier, int nRow, int nColOrg, ExecutorService pool)`
`AColGroup`
ColGroupSDC.`subtractDefaultTuple()`
`abstract AColGroup`
AColGroup.`unaryOperation(UnaryOperator op)`
Perform unary operation on the column group and return a new column group
`AColGroup`
ColGroupConst.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupDDC.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupDDCFOR.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupDDCLZW.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupDeltaDDC.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupEmpty.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupLinearFunctional.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupOLE.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupRLE.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupSDC.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupSDCFOR.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupSDCSingle.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupSDCSingleZeros.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupSDCZeros.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupUncompressed.`unaryOperation(UnaryOperator op)`
`AColGroup`
ColGroupUncompressedArray.`unaryOperation(UnaryOperator op)`
Methods in org.apache.sysds.runtime.compress.colgroup that return types with arguments of type AColGroup
Modifier and Type
Method
Description
`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 List<AColGroup>`
ColGroupIO.`readGroups(DataInput in, int nRows)`
Read groups from a file.
Methods in org.apache.sysds.runtime.compress.colgroup with parameters of type AColGroup
Modifier and Type
Method
Description
`abstract AColGroup`
AColGroup.`append(AColGroup g)`
Append the other column group to this column group.
`AColGroup`
ColGroupConst.`append(AColGroup g)`
`AColGroup`
ColGroupDDC.`append(AColGroup g)`
`AColGroup`
ColGroupDDCFOR.`append(AColGroup g)`
`AColGroup`
ColGroupDDCLZW.`append(AColGroup g)`
`AColGroup`
ColGroupDeltaDDC.`append(AColGroup g)`
`AColGroup`
ColGroupEmpty.`append(AColGroup g)`
`AColGroup`
ColGroupLinearFunctional.`append(AColGroup g)`
`AColGroup`
ColGroupOLE.`append(AColGroup g)`
`AColGroup`
ColGroupRLE.`append(AColGroup g)`
`AColGroup`
ColGroupSDC.`append(AColGroup g)`
`AColGroup`
ColGroupSDCFOR.`append(AColGroup g)`
`AColGroup`
ColGroupSDCSingle.`append(AColGroup g)`
`AColGroup`
ColGroupSDCSingleZeros.`append(AColGroup g)`
`AColGroup`
ColGroupSDCZeros.`append(AColGroup g)`
`AColGroup`
ColGroupUncompressed.`append(AColGroup g)`
`AColGroup`
ColGroupUncompressedArray.`append(AColGroup g)`
`static AColGroup`
AColGroup.`appendN(AColGroup[] groups, int blen, int rlen)`
Append all column groups in the list provided together in one go allocating the output once.
`AColGroup`
ColGroupConst.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupDDC.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupDDCFOR.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupDeltaDDC.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupEmpty.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupLinearFunctional.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupOLE.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupRLE.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDC.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCFOR.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCSingle.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCSingleZeros.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupSDCZeros.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
ColGroupUncompressed.`appendNInternal(AColGroup[] g, int blen, int rlen)`
`AColGroup`
AColGroup.`combine(AColGroup other, int nRow)`
Combine this column group with another
`AColGroup`
AColGroup.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
C bind the given column group to this.
`AColGroup`
ColGroupConst.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroupCompressed`
ColGroupDDC.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupDDCFOR.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupEmpty.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroupCompressed`
ColGroupSDC.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroupCompressed`
ColGroupSDCFOR.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroupCompressed`
ColGroupSDCSingle.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroupCompressed`
ColGroupSDCSingleZeros.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroupCompressed`
ColGroupSDCZeros.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`AColGroup`
ColGroupUncompressed.`combineWithSameIndex(int nRow, int nCol, AColGroup right)`
`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)
`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)`
`boolean`
AColGroup.`sameIndexStructure(AColGroup that)`
Method to determine if the columnGroup have the same index structure as another.
`boolean`
AColGroupCompressed.`sameIndexStructure(AColGroup that)`
`boolean`
ColGroupUncompressed.`sameIndexStructure(AColGroup that)`
`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)`
Method parameters in org.apache.sysds.runtime.compress.colgroup with type arguments of type AColGroup
Modifier and Type
Method
Description
`static double[]`
AColGroup.`colSum(Collection<AColGroup> groups, double[] res, int nRows)`
Compute the column sum of the given list of groups
`static double[]`
IContainDefaultTuple.`combineDefaultTuples(double[] defTup, List<AColGroup> right)`
`AColGroup`
AColGroup.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
C bind the list of column groups with this column group.
`AColGroup`
ColGroupConst.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroupCompressed`
ColGroupDDC.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupDDCFOR.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupEmpty.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroupCompressed`
ColGroupSDC.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroupCompressed`
ColGroupSDCFOR.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroupCompressed`
ColGroupSDCSingle.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroupCompressed`
ColGroupSDCSingleZeros.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroupCompressed`
ColGroupSDCZeros.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`AColGroup`
ColGroupUncompressed.`combineWithSameIndex(int nRow, int nCol, List<AColGroup> right)`
`static long`
ColGroupIO.`getExactSizeOnDisk(List<AColGroup> colGroups)`
Get the size on disk for the given list of column groups
`static void`
ColGroupIO.`writeGroups(DataOutput out, Collection<AColGroup> colGroups)`
Writes the ColGroups out to the DataOutput.

## Uses of AColGroup in org.apache.sysds.runtime.compress.colgroup.indexes

Methods in org.apache.sysds.runtime.compress.colgroup.indexes with parameters of type AColGroup
Modifier and Type
Method
Description
`static IColIndex`
ColIndexFactory.`combine(AColGroup a, AColGroup b)`
Method parameters in org.apache.sysds.runtime.compress.colgroup.indexes with type arguments of type AColGroup
Modifier and Type
Method
Description
`static IColIndex`
ColIndexFactory.`combine(List<? extends AColGroup> gs)`

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

Methods in org.apache.sysds.runtime.compress.colgroup.scheme that return AColGroup
Modifier and Type
Method
Description
`final AColGroup`
ACLAScheme.`encode(MatrixBlock data)`
`final AColGroup`
ACLAScheme.`encode(MatrixBlock data, IColIndex columns)`
`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.
Methods in org.apache.sysds.runtime.compress.colgroup.scheme that return types with arguments of type AColGroup
Modifier and Type
Method
Description
`final Pair<ICLAScheme,AColGroup>`
ACLAScheme.`updateAndEncode(MatrixBlock data)`
`final Pair<ICLAScheme,AColGroup>`
ACLAScheme.`updateAndEncode(MatrixBlock data, IColIndex columns)`
`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.

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

Methods in org.apache.sysds.runtime.compress.cost with parameters of type AColGroup
Modifier and Type
Method
Description
`abstract double`
ACostEstimate.`getCost(AColGroup cg, int nRows)`
Get the cost of a compressed columnGroup.
`double`
ComputationCostEstimator.`getCost(AColGroup cg, int nRows)`
`double`
DistinctCostEstimator.`getCost(AColGroup cg, int nRows)`
`double`
HybridCostEstimator.`getCost(AColGroup cg, int nRows)`
`double`
MemoryCostEstimator.`getCost(AColGroup cg, int nRows)`
Method parameters in org.apache.sysds.runtime.compress.cost with type arguments of type AColGroup
Modifier and Type
Method
Description
`double`
ACostEstimate.`getCost(Collection<AColGroup> cgs, int nRows)`
Get the cost of a collection of column groups.

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

Fields in org.apache.sysds.runtime.compress.lib with type parameters of type AColGroup
Modifier and Type
Field
Description
`final List<AColGroup>`
CLALibSeparator.SeparatedGroups.`indexStructures`
Methods in org.apache.sysds.runtime.compress.lib that return AColGroup
Modifier and Type
Method
Description
`static AColGroup`
CLALibCombineGroups.`combine(AColGroup a, AColGroup b, int nRow)`
Combine the column groups A and B together.
`static AColGroup`
CLALibCombineGroups.`combineN(List<AColGroup> groups, int nRows, ExecutorService pool, int k)`
`static AColGroup`
CLALibCombineGroups.`combineNMergeTree(List<AColGroup> groups, int nRows, ExecutorService pool, int k)`
`static AColGroup`
CLALibCombineGroups.`combineNSingleAtATime(List<AColGroup> groups, int nRows)`
Methods in org.apache.sysds.runtime.compress.lib that return types with arguments of type AColGroup
Modifier and Type
Method
Description
`static List<AColGroup>`
CLALibCombineGroups.`combine(CompressedMatrixBlock cmb, CompressedSizeInfo csi, ExecutorService pool, int k)`
`static List<AColGroup>`
CLALibSeparator.`combine(List<AColGroup> gs, Map<Integer,List<IDictionary>> d, int blen)`
Combine a set of separated groups back together.
`static List<AColGroup>`
CLALibCombineGroups.`findGroupsInIndex(IColIndex idx, List<AColGroup> groups)`
Methods in org.apache.sysds.runtime.compress.lib with parameters of type AColGroup
Modifier and Type
Method
Description
`static AColGroup`
CLALibCombineGroups.`combine(AColGroup a, AColGroup b, int nRow)`
Combine the column groups A and B together.
Method parameters in org.apache.sysds.runtime.compress.lib with type arguments of type AColGroup
Modifier and Type
Method
Description
`static List<AColGroup>`
CLALibSeparator.`combine(List<AColGroup> gs, Map<Integer,List<IDictionary>> d, int blen)`
Combine a set of separated groups back together.
`static AColGroup`
CLALibCombineGroups.`combineN(List<AColGroup> groups, int nRows, ExecutorService pool, int k)`
`static AColGroup`
CLALibCombineGroups.`combineNMergeTree(List<AColGroup> groups, int nRows, ExecutorService pool, int k)`
`static AColGroup`
CLALibCombineGroups.`combineNSingleAtATime(List<AColGroup> groups, int nRows)`
`static void`
CLALibDecompress.`decompressDense(MatrixBlock ret, List<AColGroup> groups, double[] constV, double eps, int k, boolean overlapping)`
`static List<AColGroup>`
CLALibCombineGroups.`findGroupsInIndex(IColIndex idx, List<AColGroup> groups)`
`static CLALibSeparator.SeparatedGroups`
CLALibSeparator.`split(List<AColGroup> gs)`
Split a given list of column groups into separate subparts.