# Uses of Interface
org.apache.sysds.runtime.compress.colgroup.indexes.IColIndex

Packages that use IColIndex
Package
Description
org.apache.sysds.runtime.compress.bitmap
org.apache.sysds.runtime.compress.cocode
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.indexes
org.apache.sysds.runtime.compress.colgroup.mapping
org.apache.sysds.runtime.compress.colgroup.scheme
org.apache.sysds.runtime.compress.estim
org.apache.sysds.runtime.compress.estim.encoding
org.apache.sysds.runtime.compress.lib
org.apache.sysds.runtime.compress.plan
org.apache.sysds.runtime.compress.readers
org.apache.sysds.runtime.compress.utils

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

Methods in org.apache.sysds.runtime.compress.bitmap with parameters of type IColIndex
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 IColIndex in org.apache.sysds.runtime.compress.cocode

Constructors in org.apache.sysds.runtime.compress.cocode with parameters of type IColIndex
Modifier
Constructor
Description
``
`ColIndexes(IColIndex indexes)`

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

Methods in org.apache.sysds.runtime.compress.colgroup that return IColIndex
Modifier and Type
Method
Description
`final IColIndex`
AColGroup.`getColIndices()`
Obtain the offsets of the columns in the matrix block that make up the group
Methods in org.apache.sysds.runtime.compress.colgroup with parameters of type IColIndex
Modifier and Type
Method
Description
`static void`
ColGroupUtils.`addMatrixToResult(MatrixBlock tmp, MatrixBlock result, IColIndex colIndexes, int rl, int ru)`
`static double[]`
ColGroupUtils.`binaryDefRowLeft(BinaryOperator op, double[] v, IColIndex colIndexes)`
Calculate the result of performing the binary operation on an empty row to the left v op empty
`static double[]`
ColGroupUtils.`binaryDefRowRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
Calculate the result of performing the binary operation on an empty row to the right empty op v
`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(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(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 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 void`
ColGroupUtils.`outerProduct(double[] leftRowSum, double[] rightColumnSum, IColIndex colIdxRight, double[] result, int nColR, int rl, int ru)`
`static void`
ColGroupUtils.`outerProduct(double[] leftRowSum, SparseBlock rightColSum, IColIndex colIdxRight, double[] result, int nColR, int rl, int ru)`
`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)`
Constructors in org.apache.sysds.runtime.compress.colgroup with parameters of type IColIndex
Modifier
Constructor
Description
``
`ColGroupEmpty(IColIndex colIndices)`
Constructs an Constant Colum Group, that contains only one tuple, with the given value.
``
`ColGroupUncompressedArray(Array<?> data, int id, IColIndex colIndexes)`

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

Methods in org.apache.sysds.runtime.compress.colgroup.dictionary with parameters of type IColIndex
Modifier and Type
Method
Description
`void`
ADictionary.`aggregateCols(double[] c, Builtin fn, IColIndex colIndexes)`
`void`
Dictionary.`aggregateCols(double[] c, Builtin fn, IColIndex colIndexes)`
`void`
IdentityDictionary.`aggregateCols(double[] c, Builtin fn, IColIndex colIndexes)`
`void`
IdentityDictionarySlice.`aggregateCols(double[] c, Builtin fn, IColIndex colIndexes)`
`void`
IDictionary.`aggregateCols(double[] c, Builtin fn, IColIndex colIndexes)`
Aggregates the columns into the target double array provided.
`void`
MatrixBlockDictionary.`aggregateCols(double[] c, Builtin fn, IColIndex colIndexes)`
`void`
ADictionary.`aggregateColsWithReference(double[] c, Builtin fn, IColIndex colIndexes, double[] reference, boolean def)`
`void`
Dictionary.`aggregateColsWithReference(double[] c, Builtin fn, IColIndex colIndexes, double[] reference, boolean def)`
`void`
IDictionary.`aggregateColsWithReference(double[] c, Builtin fn, IColIndex colIndexes, double[] reference, boolean def)`
Aggregates the columns into the target double array provided.
`void`
MatrixBlockDictionary.`aggregateColsWithReference(double[] c, Builtin fn, IColIndex colIndexes, double[] reference, boolean def)`
`IDictionary`
ADictionary.`binOpLeft(BinaryOperator op, double[] v, IColIndex colIndexes)`
`final Dictionary`
Dictionary.`binOpLeft(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IDictionary.`binOpLeft(BinaryOperator op, double[] v, IColIndex colIndexes)`
Apply binary row operation on the left side
`IDictionary`
MatrixBlockDictionary.`binOpLeft(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
ADictionary.`binOpLeftAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
Dictionary.`binOpLeftAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IDictionary.`binOpLeftAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
Apply binary row operation on the left side with one extra row evaluating with zeros.
`IDictionary`
MatrixBlockDictionary.`binOpLeftAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
ADictionary.`binOpLeftWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
`Dictionary`
Dictionary.`binOpLeftWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
`IDictionary`
IDictionary.`binOpLeftWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
Apply the binary operator such that each value is offset by the reference before application.
`MatrixBlockDictionary`
MatrixBlockDictionary.`binOpLeftWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
`IDictionary`
ADictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
`Dictionary`
Dictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IdentityDictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IDictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
Apply binary row operation on the right side.
`MatrixBlockDictionary`
MatrixBlockDictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
ADictionary.`binOpRightAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
Dictionary.`binOpRightAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IDictionary.`binOpRightAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
Apply binary row operation on the right side with one extra row evaluating with zeros.
`IDictionary`
MatrixBlockDictionary.`binOpRightAndAppend(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
ADictionary.`binOpRightWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
`Dictionary`
Dictionary.`binOpRightWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
`IDictionary`
IDictionary.`binOpRightWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
Apply the binary operator such that each value is offset by the reference before application.
`MatrixBlockDictionary`
MatrixBlockDictionary.`binOpRightWithReference(BinaryOperator op, double[] v, IColIndex colIndexes, double[] reference, double[] newReference)`
`void`
ADictionary.`colProduct(double[] res, int[] counts, IColIndex colIndexes)`
`void`
Dictionary.`colProduct(double[] res, int[] counts, IColIndex colIndexes)`
`void`
IdentityDictionary.`colProduct(double[] res, int[] counts, IColIndex colIndexes)`
`void`
IDictionary.`colProduct(double[] res, int[] counts, IColIndex colIndexes)`
Calculate the column product of the dictionary weighted by counts.
`void`
MatrixBlockDictionary.`colProduct(double[] res, int[] counts, IColIndex colIndexes)`
`void`
ADictionary.`colProductWithReference(double[] res, int[] counts, IColIndex colIndexes, double[] reference)`
`void`
Dictionary.`colProductWithReference(double[] res, int[] counts, IColIndex colIndexes, double[] reference)`
`void`
IDictionary.`colProductWithReference(double[] res, int[] counts, IColIndex colIndexes, double[] reference)`
Calculate the column product of the dictionary weighted by counts.
`void`
MatrixBlockDictionary.`colProductWithReference(double[] res, int[] counts, IColIndex colIndexes, double[] reference)`
`void`
ADictionary.`colSum(double[] c, int[] counts, IColIndex colIndexes)`
`void`
Dictionary.`colSum(double[] c, int[] counts, IColIndex colIndexes)`
`void`
IdentityDictionary.`colSum(double[] c, int[] counts, IColIndex colIndexes)`
`void`
IdentityDictionarySlice.`colSum(double[] c, int[] counts, IColIndex colIndexes)`
`void`
IDictionary.`colSum(double[] c, int[] counts, IColIndex colIndexes)`
Get the column sum of the values contained in the dictionary
`void`
MatrixBlockDictionary.`colSum(double[] c, int[] counts, IColIndex colIndexes)`
`void`
ADictionary.`colSumSq(double[] c, int[] counts, IColIndex colIndexes)`
`void`
Dictionary.`colSumSq(double[] c, int[] counts, IColIndex colIndexes)`
`void`
IdentityDictionary.`colSumSq(double[] c, int[] counts, IColIndex colIndexes)`
`void`
IDictionary.`colSumSq(double[] c, int[] counts, IColIndex colIndexes)`
Get the column sum of the values contained in the dictionary
`void`
MatrixBlockDictionary.`colSumSq(double[] c, int[] counts, IColIndex colIndexes)`
`void`
ADictionary.`colSumSqWithReference(double[] c, int[] counts, IColIndex colIndexes, double[] reference)`
`void`
Dictionary.`colSumSqWithReference(double[] c, int[] counts, IColIndex colIndexes, double[] reference)`
`void`
IDictionary.`colSumSqWithReference(double[] c, int[] counts, IColIndex colIndexes, double[] reference)`
Get the column sum of the values contained in the dictionary with an offset reference value added to each cell.
`void`
MatrixBlockDictionary.`colSumSqWithReference(double[] c, int[] counts, IColIndex colIndexes, double[] reference)`
`static IDictionary`
DictionaryFactory.`combineFullDictionaries(IDictionary a, IColIndex ai, int nca, IDictionary b, IColIndex bi, int ncb, HashMapLongInt filter)`
`static IDictionary`
DictionaryFactory.`combineFullDictionaries(IDictionary a, IColIndex ai, IDictionary b, IColIndex bi, HashMapLongInt filter)`
`static IDictionary`
DictionaryFactory.`combineSDCFilter(IDictionary a, double[] tua, IColIndex ai, IDictionary b, double[] tub, IColIndex bi, HashMapLongInt filter)`
`static IDictionary`
DictionaryFactory.`combineSDCNoFilter(IDictionary a, double[] tua, IColIndex ai, IDictionary b, double[] tub, IColIndex bi)`
`static IDictionary`
DictionaryFactory.`combineSDCRight(IDictionary a, IColIndex ai, int nca, IDictionary b, double[] tub, IColIndex bi, HashMapLongInt filter)`
`static IDictionary`
DictionaryFactory.`combineSDCRight(IDictionary a, IColIndex ai, IDictionary b, double[] tub, IColIndex bi, HashMapLongInt filter)`
`static IDictionary`
DictionaryFactory.`combineSDCRightNoFilter(IDictionary a, IColIndex ai, int nca, IDictionary b, double[] tub, IColIndex bi)`
`static void`
ADictionary.`correctNan(double[] res, IColIndex colIndexes)`
Correct Nan Values in an result.
`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)
`void`
ADictionary.`multiplyScalar(double v, double[] ret, int off, int dictIdx, IColIndex cols)`
`void`
Dictionary.`multiplyScalar(double v, double[] ret, int off, int dictIdx, IColIndex cols)`
`void`
IdentityDictionary.`multiplyScalar(double v, double[] ret, int off, int dictIdx, IColIndex cols)`
`void`
IDictionary.`multiplyScalar(double v, double[] ret, int off, int dictIdx, IColIndex cols)`
Multiply the v value with the dictionary entry at dictIdx and add it to the ret matrix at the columns specified in the int array.
`void`
MatrixBlockDictionary.`multiplyScalar(double v, double[] ret, int off, int dictIdx, IColIndex cols)`
`IDictionary`
ADictionary.`preaggValuesFromDense(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut)`
`Dictionary`
Dictionary.`preaggValuesFromDense(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut)`
`IDictionary`
IdentityDictionary.`preaggValuesFromDense(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut)`
`IDictionary`
IDictionary.`preaggValuesFromDense(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut)`
Pre Aggregate values for Right Matrix Multiplication.
`MatrixBlockDictionary`
MatrixBlockDictionary.`preaggValuesFromDense(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut)`
`void`
MatrixBlockDictionary.`preaggValuesFromDenseDictDense(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut, double[] ret)`
`void`
MatrixBlockDictionary.`preaggValuesFromDenseDictSparse(int numVals, IColIndex colIndexes, IColIndex aggregateColumns, double[] b, int cut, double[] ret)`
`void`
ADictionary.`putDense(DenseBlock dr, int idx, int rowOut, int nCol, IColIndex columns)`
`void`
IDictionary.`putDense(DenseBlock db, int idx, int rowOut, int nCol, IColIndex columns)`
Put the row specified into the sparse block, via append calls.
`void`
ADictionary.`putSparse(SparseBlock sb, int idx, int rowOut, int nCol, IColIndex columns)`
`void`
IDictionary.`putSparse(SparseBlock sb, int idx, int rowOut, int nCol, IColIndex columns)`
Put the row specified into the sparse block, via append calls.
`IDictionary`
ADictionary.`rightMMPreAggSparse(int numVals, SparseBlock b, IColIndex thisCols, IColIndex aggregateColumns, int nColRight)`
`IDictionary`
IDictionary.`rightMMPreAggSparse(int numVals, SparseBlock b, IColIndex thisCols, IColIndex aggregateColumns, int nColRight)`
Pre-aggregate the given sparse block for right multiplication.
`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 IColIndex in org.apache.sysds.runtime.compress.colgroup.functional

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

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

Classes in org.apache.sysds.runtime.compress.colgroup.indexes that implement IColIndex
Modifier and Type
Class
Description
`class`
`AColIndex`
`class`
`ArrayIndex`
`class`
`CombinedIndex`
`class`
`RangeIndex`
A Range index that contain a lower and upper bound of the indexes that is symbolize.
`class`
`SingleIndex`
`class`
`TwoIndex`
`class`
`TwoRangesIndex`
Fields in org.apache.sysds.runtime.compress.colgroup.indexes declared as IColIndex
Modifier and Type
Field
Description
`final IColIndex`
IColIndex.SliceResult.`ret`
The already modified column index to return on slices
Methods in org.apache.sysds.runtime.compress.colgroup.indexes that return IColIndex
Modifier and Type
Method
Description
`IColIndex`
ArrayIndex.`combine(IColIndex other)`
`static IColIndex`
ColIndexFactory.`combine(List<? extends AColGroup> gs)`
`static IColIndex`
ColIndexFactory.`combine(AColGroup a, AColGroup b)`
`static IColIndex`
ColIndexFactory.`combine(IColIndex a, IColIndex b)`
`IColIndex`
CombinedIndex.`combine(IColIndex other)`
`IColIndex`
IColIndex.`combine(IColIndex other)`
combine the indexes of this colIndex with another, it is expected that all calls to this contains unique indexes, and no copies of values.
`IColIndex`
RangeIndex.`combine(IColIndex other)`
`IColIndex`
SingleIndex.`combine(IColIndex other)`
`IColIndex`
TwoIndex.`combine(IColIndex other)`
`IColIndex`
TwoRangesIndex.`combine(IColIndex other)`
`static IColIndex`
ColIndexFactory.`combineIndexes(List<IColIndex> idx)`
`static IColIndex`
ColIndexFactory.`create(int nCol)`
`static IColIndex`
ColIndexFactory.`create(int[] indexes)`
`static IColIndex`
ColIndexFactory.`create(int l, int u)`
Create an Index range of the given values
`static IColIndex`
ColIndexFactory.`create(IntArrayList indexes)`
`static IColIndex`
ColIndexFactory.`createI(int... indexes)`
`static IColIndex`
ColIndexFactory.`getColumnMapping(IColIndex comb, IColIndex a)`
Provide a mapping from a to the combined columns shifted over to column positions in the combined.
`static IColIndex`
ColIndexFactory.`read(DataInput in)`
`IColIndex`
ArrayIndex.`shift(int i)`
`IColIndex`
CombinedIndex.`shift(int i)`
`IColIndex`
IColIndex.`shift(int i)`
Return a new column index where the values are shifted by the specified amount.
`IColIndex`
TwoRangesIndex.`shift(int i)`
`IColIndex`
ArrayIndex.`sort()`
`IColIndex`
CombinedIndex.`sort()`
`IColIndex`
IColIndex.`sort()`
Sort the index and return a new object if there are modifications otherwise return this.
`IColIndex`
RangeIndex.`sort()`
`IColIndex`
SingleIndex.`sort()`
`IColIndex`
TwoIndex.`sort()`
`IColIndex`
TwoRangesIndex.`sort()`
Methods in org.apache.sysds.runtime.compress.colgroup.indexes with parameters of type IColIndex
Modifier and Type
Method
Description
`IColIndex`
ArrayIndex.`combine(IColIndex other)`
`static IColIndex`
ColIndexFactory.`combine(IColIndex a, IColIndex b)`
`IColIndex`
CombinedIndex.`combine(IColIndex other)`
`IColIndex`
IColIndex.`combine(IColIndex other)`
combine the indexes of this colIndex with another, it is expected that all calls to this contains unique indexes, and no copies of values.
`IColIndex`
RangeIndex.`combine(IColIndex other)`
`IColIndex`
SingleIndex.`combine(IColIndex other)`
`IColIndex`
TwoIndex.`combine(IColIndex other)`
`IColIndex`
TwoRangesIndex.`combine(IColIndex other)`
`boolean`
AColIndex.`contains(IColIndex a, IColIndex b)`
`boolean`
IColIndex.`contains(IColIndex a, IColIndex b)`
This contains method is not strict since it only verifies one element is contained from each a and b.
`boolean`
AColIndex.`containsAny(IColIndex idx)`
`boolean`
IColIndex.`containsAny(IColIndex idx)`
Analyze if this column group contain any of the given column Ids.
`boolean`
RangeIndex.`containsAny(IColIndex idx)`
`boolean`
SingleIndex.`containsAny(IColIndex idx)`
`boolean`
TwoRangesIndex.`containsAny(IColIndex idx)`
`boolean`
AColIndex.`containsStrict(IColIndex a, IColIndex b)`
`boolean`
IColIndex.`containsStrict(IColIndex a, IColIndex b)`
This contains both a and b ...
`boolean`
ArrayIndex.`equals(IColIndex other)`
`boolean`
CombinedIndex.`equals(IColIndex other)`
`boolean`
IColIndex.`equals(IColIndex other)`
`boolean`
RangeIndex.`equals(IColIndex other)`
`boolean`
SingleIndex.`equals(IColIndex other)`
`boolean`
TwoIndex.`equals(IColIndex other)`
`boolean`
TwoRangesIndex.`equals(IColIndex other)`
`static IColIndex`
ColIndexFactory.`getColumnMapping(IColIndex comb, IColIndex a)`
Provide a mapping from a to the combined columns shifted over to column positions in the combined.
`static boolean`
IColIndex.`inOrder(IColIndex a, IColIndex b)`
Indicate if the two given column indexes are in order such that the first set of indexes all are of lower value than the second.
`static Pair<int[],int[]>`
IColIndex.`reorderingIndexes(IColIndex a, IColIndex b)`
Method parameters in org.apache.sysds.runtime.compress.colgroup.indexes with type arguments of type IColIndex
Modifier and Type
Method
Description
`static IColIndex`
ColIndexFactory.`combineIndexes(List<IColIndex> idx)`
Constructors in org.apache.sysds.runtime.compress.colgroup.indexes with parameters of type IColIndex
Modifier
Constructor
Description
``
`CombinedIndex(IColIndex l, IColIndex r)`

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

Methods in org.apache.sysds.runtime.compress.colgroup.mapping with parameters of type IColIndex
Modifier and Type
Method
Description
`void`
AMapToData.`lmSparseMatrixRow(SparseBlock sb, int r, DenseBlock db, IColIndex colIndexes, IDictionary dict)`
`void`
MapToByte.`lmSparseMatrixRow(SparseBlock sb, int r, DenseBlock db, IColIndex colIndexes, IDictionary dict)`
`void`
MapToChar.`lmSparseMatrixRow(SparseBlock sb, int r, DenseBlock db, IColIndex colIndexes, IDictionary dict)`
`void`
MapToCharPByte.`lmSparseMatrixRow(SparseBlock sb, int r, DenseBlock db, IColIndex colIndexes, IDictionary dict)`

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

Methods in org.apache.sysds.runtime.compress.colgroup.scheme with parameters of type IColIndex
Modifier and Type
Method
Description
`static ICLAScheme`
ConstScheme.`create(IColIndex cols, double[] vals)`
`static DDCLZWScheme`
DDCLZWScheme.`create(IColIndex cols)`
`static DDCScheme`
DDCScheme.`create(IColIndex cols)`
Create a scheme for the DDC compression given a list of columns.
`static ICLAScheme`
SchemeFactory.`create(IColIndex columns, AColGroup.CompressionType type)`
`final AColGroup`
ACLAScheme.`encode(MatrixBlock data, IColIndex columns)`
`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, IColIndex columns)`
`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, IColIndex columns)`
`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, IColIndex columns)`
`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, IColIndex columns)`
`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, IColIndex columns)`
`ICLAScheme`
ICLAScheme.`updateT(MatrixBlock data, IColIndex columns)`
Update the encoding scheme to enable compression of the given data.
Constructors in org.apache.sysds.runtime.compress.colgroup.scheme with parameters of type IColIndex
Modifier
Constructor
Description
``
`EmptyScheme(IColIndex idx)`
``
`RLEScheme(IColIndex cols)`
``
`SDCSchemeMC(IColIndex cols, DblArrayCountHashMap map, DblArray def)`
``
`SDCSchemeSC(IColIndex cols, DoubleCountHashMap map, double def)`
``
`UncompressedScheme(IColIndex cols)`

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

Methods in org.apache.sysds.runtime.compress.estim that return IColIndex
Modifier and Type
Method
Description
`IColIndex`
CompressedSizeInfoColGroup.`getColumns()`
Methods in org.apache.sysds.runtime.compress.estim with parameters of type IColIndex
Modifier and Type
Method
Description
`final CompressedSizeInfoColGroup`
AComEst.`combine(IColIndex combinedColumns, CompressedSizeInfoColGroup g1, CompressedSizeInfoColGroup g2)`
Combine two analyzed column groups together.
`final CompressedSizeInfoColGroup`
AComEst.`getColGroupInfo(IColIndex colIndexes)`
Method for extracting Compressed Size Info of specified columns, together in a single ColGroup
`abstract CompressedSizeInfoColGroup`
AComEst.`getColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
A method to extract the Compressed Size Info for a given list of columns, This method further limits the estimated number of unique values, since in some cases the estimated number of uniques is estimated higher than the number estimated in sub groups of the given colIndexes.
`CompressedSizeInfoColGroup`
ComEstCompressed.`getColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
`CompressedSizeInfoColGroup`
ComEstCompressedSample.`getColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
`CompressedSizeInfoColGroup`
ComEstExact.`getColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
`CompressedSizeInfoColGroup`
ComEstSample.`getColGroupInfo(IColIndex colIndexes, int estimate, int maxDistinct)`
`final CompressedSizeInfoColGroup`
AComEst.`getDeltaColGroupInfo(IColIndex colIndexes)`
Method for extracting info of specified columns as delta encodings (delta from previous rows values)
`abstract CompressedSizeInfoColGroup`
AComEst.`getDeltaColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
A method to extract the Compressed Size Info for a given list of columns, This method further limits the estimated number of unique values, since in some cases the estimated number of uniques is estimated higher than the number estimated in sub groups of the given colIndexes.
`CompressedSizeInfoColGroup`
ComEstCompressed.`getDeltaColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
`CompressedSizeInfoColGroup`
ComEstCompressedSample.`getDeltaColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
`CompressedSizeInfoColGroup`
ComEstExact.`getDeltaColGroupInfo(IColIndex colIndexes, int estimate, int nrUniqueUpperBound)`
`CompressedSizeInfoColGroup`
ComEstSample.`getDeltaColGroupInfo(IColIndex colIndexes, int estimate, int maxDistinct)`
Constructors in org.apache.sysds.runtime.compress.estim with parameters of type IColIndex
Modifier
Constructor
Description
``
`CompressedSizeInfoColGroup(IColIndex cols, int nVal, int nRow, AColGroup.CompressionType bestCompressionType)`
``
`CompressedSizeInfoColGroup(IColIndex columns, int nRows, AColGroup.CompressionType ct)`
Create empty or const.
``
`CompressedSizeInfoColGroup(IColIndex cols, EstimationFactors facts, long minSize, AColGroup.CompressionType bestCompressionType)`
``
`CompressedSizeInfoColGroup(IColIndex columns, EstimationFactors facts, long minSize, AColGroup.CompressionType bestCompression, IEncode map)`
``
`CompressedSizeInfoColGroup(IColIndex columns, EstimationFactors facts, Set<AColGroup.CompressionType> validCompressionTypes, IEncode map)`
``
`CompressedSizeInfoColGroup(IColIndex cols, EstimationFactors facts, AColGroup.CompressionType bestCompressionType)`

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

Methods in org.apache.sysds.runtime.compress.estim.encoding with parameters of type IColIndex
Modifier and Type
Method
Description
`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 IColIndex in org.apache.sysds.runtime.compress.lib

Methods in org.apache.sysds.runtime.compress.lib with parameters of type IColIndex
Modifier and Type
Method
Description
`static List<AColGroup>`
CLALibCombineGroups.`findGroupsInIndex(IColIndex idx, List<AColGroup> groups)`

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

Methods in org.apache.sysds.runtime.compress.plan with parameters of type IColIndex
Modifier and Type
Method
Description
`static IPlanEncode`
CompressionPlanFactory.`create(IColIndex[] columnGroups, AColGroup.CompressionType[] type, int k)`

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

Methods in org.apache.sysds.runtime.compress.readers with parameters of type IColIndex
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 IColIndex in org.apache.sysds.runtime.compress.utils

Methods in org.apache.sysds.runtime.compress.utils with parameters of type IColIndex
Modifier and Type
Method
Description
`static MatrixBlock`
Util.`extractValues(double[] v, IColIndex colIndexes)`