# Uses of Interface
org.apache.sysds.runtime.compress.colgroup.dictionary.IDictionary

Packages that use IDictionary
Package
Description
org.apache.sysds.runtime.compress.colgroup
org.apache.sysds.runtime.compress.colgroup.dictionary
org.apache.sysds.runtime.compress.colgroup.mapping
org.apache.sysds.runtime.compress.io
org.apache.sysds.runtime.compress.lib

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

Methods in org.apache.sysds.runtime.compress.colgroup that return IDictionary
Modifier and Type
Method
Description
`IDictionary`
ADictBasedColGroup.`getDictionary()`
`IDictionary`
IContainADictionary.`getDictionary()`
`final IDictionary`
APreAgg.`preAggregateThatIndexStructure(APreAgg that)`
Pre aggregate into a dictionary.
Methods in org.apache.sysds.runtime.compress.colgroup with parameters of type IDictionary
Modifier and Type
Method
Description
`final AColGroup`
ADictBasedColGroup.`copyAndSet(IDictionary newDictionary)`
This method copies the column group and sets the dictionary to another dictionary.
`static AColGroup`
ColGroupConst.`create(int numCols, IDictionary dict)`
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`
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)`

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

Classes in org.apache.sysds.runtime.compress.colgroup.dictionary that implement IDictionary
Modifier and Type
Class
Description
`class`
`ACachingMBDictionary`
`class`
`ADictionary`
This dictionary class aims to encapsulate the storage and operations over unique tuple values of a column group.
`class`
`AIdentityDictionary`
`class`
`DeltaDictionary`
This dictionary class is a specialization for the DeltaDDCColgroup.
`class`
`Dictionary`
This dictionary class aims to encapsulate the storage and operations over unique floating point values of a column group.
`class`
`IdentityDictionary`
A specialized dictionary that exploits the fact that the contained dictionary is an Identity Matrix.
`class`
`IdentityDictionarySlice`
`class`
`MatrixBlockDictionary`
`class`
`PlaceHolderDict`
`class`
`QDictionary`
This dictionary class aims to encapsulate the storage and operations over unique floating point values of a column group.
Methods in org.apache.sysds.runtime.compress.colgroup.dictionary that return IDictionary
Modifier and Type
Method
Description
`IDictionary`
ADictionary.`append(double[] row)`
`IDictionary`
Dictionary.`append(double[] row)`
`IDictionary`
IDictionary.`append(double[] row)`
Return a new dictionary with the given row appended.
`IDictionary`
MatrixBlockDictionary.`append(double[] row)`
`IDictionary`
ADictionary.`applyScalarOp(ScalarOperator op)`
`IDictionary`
Dictionary.`applyScalarOp(ScalarOperator op)`
`IDictionary`
IDictionary.`applyScalarOp(ScalarOperator op)`
Allocate a new dictionary and applies the scalar operation on each cell of to then return the new dictionary.
`IDictionary`
MatrixBlockDictionary.`applyScalarOp(ScalarOperator op)`
`IDictionary`
ADictionary.`applyScalarOpAndAppend(ScalarOperator op, double v0, int nCol)`
`IDictionary`
Dictionary.`applyScalarOpAndAppend(ScalarOperator op, double v0, int nCol)`
`IDictionary`
IDictionary.`applyScalarOpAndAppend(ScalarOperator op, double v0, int nCol)`
Allocate a new dictionary with one extra row and applies the scalar operation on each cell of to then return the new dictionary.
`IDictionary`
MatrixBlockDictionary.`applyScalarOpAndAppend(ScalarOperator op, double v0, int nCol)`
`IDictionary`
ADictionary.`applyScalarOpWithReference(ScalarOperator op, double[] reference, double[] newReference)`
`IDictionary`
IDictionary.`applyScalarOpWithReference(ScalarOperator op, double[] reference, double[] newReference)`
Allocate a new dictionary and apply the scalar operation on each cell to then return a new dictionary.
`IDictionary`
MatrixBlockDictionary.`applyScalarOpWithReference(ScalarOperator op, double[] reference, double[] newReference)`
`IDictionary`
ADictionary.`applyUnaryOp(UnaryOperator op)`
`IDictionary`
IDictionary.`applyUnaryOp(UnaryOperator op)`
Allocate a new dictionary and apply the unary operator on each cell.
`IDictionary`
MatrixBlockDictionary.`applyUnaryOp(UnaryOperator op)`
`IDictionary`
ADictionary.`applyUnaryOpAndAppend(UnaryOperator op, double v0, int nCol)`
`IDictionary`
Dictionary.`applyUnaryOpAndAppend(UnaryOperator op, double v0, int nCol)`
`IDictionary`
IDictionary.`applyUnaryOpAndAppend(UnaryOperator op, double v0, int nCol)`
Allocate a new dictionary with one extra row and apply the unary operator on each cell.
`IDictionary`
MatrixBlockDictionary.`applyUnaryOpAndAppend(UnaryOperator op, double v0, int nCol)`
`IDictionary`
ADictionary.`applyUnaryOpWithReference(UnaryOperator op, double[] reference, double[] newReference)`
`IDictionary`
Dictionary.`applyUnaryOpWithReference(UnaryOperator op, double[] reference, double[] newReference)`
`IDictionary`
IDictionary.`applyUnaryOpWithReference(UnaryOperator op, double[] reference, double[] newReference)`
Allocate a new dictionary and apply the scalar operation on each cell to then return a new dictionary.
`IDictionary`
MatrixBlockDictionary.`applyUnaryOpWithReference(UnaryOperator op, double[] reference, double[] newReference)`
`IDictionary`
ADictionary.`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)`
`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.
`IDictionary`
ADictionary.`binOpRight(BinaryOperator op, double[] v)`
`IDictionary`
ADictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IdentityDictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
`IDictionary`
IDictionary.`binOpRight(BinaryOperator op, double[] v)`
Apply binary row operation on the right side as with no columns to extract from v.
`IDictionary`
IDictionary.`binOpRight(BinaryOperator op, double[] v, IColIndex colIndexes)`
Apply binary row operation on the right side.
`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)`
`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.
`IDictionary`
ADictionary.`cbind(IDictionary that, int nCol)`
`IDictionary`
Dictionary.`cbind(IDictionary that, int nCol)`
`IDictionary`
IDictionary.`cbind(IDictionary that, int nCol)`
Cbind this dictionary with that dictionary
`IDictionary`
MatrixBlockDictionary.`cbind(IDictionary that, int nCol)`
`static IDictionary`
DictionaryFactory.`cBindDictionaries(int nCol, List<IDictionary> dicts)`
`static IDictionary`
DictionaryFactory.`cBindDictionaries(IDictionary left, IDictionary right, int nColLeft, int nColRight)`
`abstract IDictionary`
ADictionary.`clone()`
`IDictionary`
DeltaDictionary.`clone()`
`IDictionary`
IdentityDictionary.`clone()`
`IDictionary`
IdentityDictionarySlice.`clone()`
`IDictionary`
IDictionary.`clone()`
Returns a deep clone of the dictionary.
`IDictionary`
MatrixBlockDictionary.`clone()`
`IDictionary`
PlaceHolderDict.`clone()`
`static IDictionary`
DictionaryFactory.`combineDictionaries(AColGroupCompressed a, AColGroupCompressed b)`
`static IDictionary`
DictionaryFactory.`combineDictionaries(AColGroupCompressed a, AColGroupCompressed b, HashMapLongInt filter)`
`static IDictionary`
DictionaryFactory.`combineDictionariesSparse(AColGroupCompressed a, AColGroupCompressed b)`
Combine the dictionaries assuming a sparse combination where each dictionary can be a SDC containing a default element that have to be introduced into the combined dictionary.
`static IDictionary`
DictionaryFactory.`combineDictionariesSparse(AColGroupCompressed a, AColGroupCompressed b, HashMapLongInt filter)`
Combine the dictionaries assuming a sparse combination where each dictionary can be a SDC containing a default element that have to be introduced into the combined dictionary.
`static IDictionary`
DictionaryFactory.`combineFullDictionaries(IDictionary a, int nca, IDictionary b, int ncb)`
Combine the dictionaries as if the dictionaries contain the full spectrum of the combined data.
`static IDictionary`
DictionaryFactory.`combineFullDictionaries(IDictionary a, int nca, IDictionary b, int ncb, HashMapLongInt filter)`
Combine the dictionaries as if the dictionaries only contain the values in the specified filter.
`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, IDictionary b, double[] tub, 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, IDictionary b, double[] tub)`
`static IDictionary`
DictionaryFactory.`combineSDCNoFilter(IDictionary a, double[] tua, IColIndex ai, IDictionary b, double[] tub, IColIndex bi)`
`static IDictionary`
DictionaryFactory.`combineSDCRight(IDictionary a, int nca, IDictionary b, double[] tub, HashMapLongInt filter)`
`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, int nca, IDictionary b, double[] tub)`
`static IDictionary`
DictionaryFactory.`combineSDCRightNoFilter(IDictionary a, IColIndex ai, int nca, IDictionary b, double[] tub, IColIndex bi)`
`static IDictionary`
DictionaryFactory.`create(ABitmap ubm)`
`static IDictionary`
DictionaryFactory.`create(ABitmap ubm, double sparsity)`
`static IDictionary`
DictionaryFactory.`create(ABitmap ubm, int defaultIndex, double[] defaultTuple, double sparsity, boolean addZero)`
`static IDictionary`
DictionaryFactory.`create(DblArrayCountHashMap map, int nCols, boolean addZeroTuple, double sparsity)`
`static IDictionary`
DictionaryFactory.`create(DoubleCountHashMap map)`
`static IDictionary`
IdentityDictionary.`create(int nRowCol)`
Create an identity matrix dictionary.
`static IDictionary`
IdentityDictionary.`create(int nRowCol, boolean withEmpty)`
Create an identity matrix dictionary, It behaves as if allocated a Sparse Matrix block but exploits that the structure is known to have certain properties.
`static IDictionary`
IdentityDictionarySlice.`create(int nRowCol, boolean withEmpty, int l, int u)`
Create a Identity matrix dictionary slice (if other groups are not more applicable).
`IDictionary`
ADictionary.`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.
`static IDictionary`
DictionaryFactory.`read(DataInput in)`
`IDictionary`
ADictionary.`reorder(int[] reorder)`
`IDictionary`
Dictionary.`reorder(int[] reorder)`
`IDictionary`
IDictionary.`reorder(int[] reorder)`
Reorder the elements in the dictionary based on the reorder specification given.
`IDictionary`
MatrixBlockDictionary.`reorder(int[] reorder)`
`IDictionary`
ADictionary.`replace(double pattern, double replace, int nCol)`
`IDictionary`
Dictionary.`replace(double pattern, double replace, int nCol)`
`IDictionary`
IDictionary.`replace(double pattern, double replace, int nCol)`
Make a copy of the values, and replace all values that match pattern with replacement value.
`IDictionary`
MatrixBlockDictionary.`replace(double pattern, double replace, int nCol)`
`IDictionary`
ADictionary.`replaceWithReference(double pattern, double replace, double[] reference)`
`IDictionary`
Dictionary.`replaceWithReference(double pattern, double replace, double[] reference)`
`IDictionary`
IDictionary.`replaceWithReference(double pattern, double replace, double[] reference)`
Make a copy of the values, and replace all values that match pattern with replacement value.
`IDictionary`
MatrixBlockDictionary.`replaceWithReference(double pattern, double replace, double[] reference)`
`IDictionary`
ADictionary.`rexpandCols(int max, boolean ignore, boolean cast, int nCol)`
`IDictionary`
Dictionary.`rexpandCols(int max, boolean ignore, boolean cast, int nCol)`
`IDictionary`
IDictionary.`rexpandCols(int max, boolean ignore, boolean cast, int nCol)`
Rexpand the dictionary (one hot encode)
`IDictionary`
MatrixBlockDictionary.`rexpandCols(int max, boolean ignore, boolean cast, int nCol)`
`IDictionary`
ADictionary.`rexpandColsWithReference(int max, boolean ignore, boolean cast, int reference)`
`IDictionary`
Dictionary.`rexpandColsWithReference(int max, boolean ignore, boolean cast, int reference)`
`IDictionary`
IDictionary.`rexpandColsWithReference(int max, boolean ignore, boolean cast, int reference)`
Rexpand the dictionary (one hot encode)
`IDictionary`
MatrixBlockDictionary.`rexpandColsWithReference(int max, boolean ignore, boolean cast, int reference)`
`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.
`IDictionary`
ADictionary.`scaleTuples(int[] scaling, int nCol)`
`IDictionary`
Dictionary.`scaleTuples(int[] scaling, int nCol)`
`IDictionary`
IDictionary.`scaleTuples(int[] scaling, int nCol)`
Scale all tuples contained in the dictionary by the scaling factor given in the int list.
`IDictionary`
MatrixBlockDictionary.`scaleTuples(int[] scaling, int nCol)`
`IDictionary`
DeltaDictionary.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
Dictionary.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
IdentityDictionary.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
IdentityDictionarySlice.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
IDictionary.`sliceColumns(IntArrayList selectedColumns, int nCol)`
Slice out the selected columns given of this encoded group.
`IDictionary`
MatrixBlockDictionary.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
PlaceHolderDict.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
QDictionary.`sliceColumns(IntArrayList selectedColumns, int nCol)`
`IDictionary`
ADictionary.`sliceOutColumnRange(int idxStart, int idxEnd, int previousNumberOfColumns)`
`IDictionary`
Dictionary.`sliceOutColumnRange(int idxStart, int idxEnd, int previousNumberOfColumns)`
`IDictionary`
IdentityDictionary.`sliceOutColumnRange(int idxStart, int idxEnd, int previousNumberOfColumns)`
`IDictionary`
IDictionary.`sliceOutColumnRange(int idxStart, int idxEnd, int previousNumberOfColumns)`
Modify the dictionary by removing columns not within the index range.
`IDictionary`
MatrixBlockDictionary.`sliceOutColumnRange(int idxStart, int idxEnd, int previousNumberOfColumns)`
`IDictionary`
QDictionary.`sliceOutColumnRange(int idxStart, int idxEnd, int previousNumberOfColumns)`
`IDictionary`
ADictionary.`subtractTuple(double[] tuple)`
`IDictionary`
Dictionary.`subtractTuple(double[] tuple)`
`IDictionary`
IDictionary.`subtractTuple(double[] tuple)`
Allocate a new dictionary where the tuple given is subtracted from all tuples in the previous dictionary.
`IDictionary`
MatrixBlockDictionary.`subtractTuple(double[] tuple)`
Methods in org.apache.sysds.runtime.compress.colgroup.dictionary with parameters of type IDictionary
Modifier and Type
Method
Description
`IDictionary`
ADictionary.`cbind(IDictionary that, int nCol)`
`IDictionary`
Dictionary.`cbind(IDictionary that, int nCol)`
`IDictionary`
IDictionary.`cbind(IDictionary that, int nCol)`
Cbind this dictionary with that dictionary
`IDictionary`
MatrixBlockDictionary.`cbind(IDictionary that, int nCol)`
`static IDictionary`
DictionaryFactory.`cBindDictionaries(IDictionary left, IDictionary right, int nColLeft, int nColRight)`
`static IDictionary`
DictionaryFactory.`combineFullDictionaries(IDictionary a, int nca, IDictionary b, int ncb)`
Combine the dictionaries as if the dictionaries contain the full spectrum of the combined data.
`static IDictionary`
DictionaryFactory.`combineFullDictionaries(IDictionary a, int nca, IDictionary b, int ncb, HashMapLongInt filter)`
Combine the dictionaries as if the dictionaries only contain the values in the specified filter.
`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, IDictionary b, double[] tub, 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, IDictionary b, double[] tub)`
`static IDictionary`
DictionaryFactory.`combineSDCNoFilter(IDictionary a, double[] tua, IColIndex ai, IDictionary b, double[] tub, IColIndex bi)`
`static IDictionary`
DictionaryFactory.`combineSDCRight(IDictionary a, int nca, IDictionary b, double[] tub, HashMapLongInt filter)`
`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, int nca, IDictionary b, double[] tub)`
`static IDictionary`
DictionaryFactory.`combineSDCRightNoFilter(IDictionary a, IColIndex ai, int nca, IDictionary b, double[] tub, IColIndex bi)`
`boolean`
DeltaDictionary.`equals(IDictionary o)`
`boolean`
Dictionary.`equals(IDictionary o)`
`boolean`
IdentityDictionary.`equals(IDictionary o)`
`boolean`
IdentityDictionarySlice.`equals(IDictionary o)`
`boolean`
IDictionary.`equals(IDictionary o)`
Indicate if the other dictionary is equal to this.
`boolean`
MatrixBlockDictionary.`equals(IDictionary o)`
`boolean`
PlaceHolderDict.`equals(IDictionary o)`
`boolean`
QDictionary.`equals(IDictionary o)`
`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)`
`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)`
`static void`
DictLibMatrixMult.`MMDictsWithScaling(IDictionary left, IDictionary right, IColIndex leftRows, IColIndex rightColumns, MatrixBlock result, int[] counts)`
Matrix multiply with scaling (left side transposed)
`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.`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)`
Method parameters in org.apache.sysds.runtime.compress.colgroup.dictionary with type arguments of type IDictionary
Modifier and Type
Method
Description
`static IDictionary`
DictionaryFactory.`cBindDictionaries(int nCol, List<IDictionary> dicts)`

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

Methods in org.apache.sysds.runtime.compress.colgroup.mapping with parameters of type IDictionary
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)`
`final void`
AMapToData.`preAggregateDDC_DDC(AMapToData tm, IDictionary td, Dictionary ret, int nCol)`
PreAggregate into dictionary with two sides of DDC.
`void`
MapToBit.`preAggregateDDC_DDCMultiCol(AMapToData tm, IDictionary td, double[] v, int nCol)`
`void`
MapToZero.`preAggregateDDC_DDCMultiCol(AMapToData tm, IDictionary td, double[] v, int nCol)`
`void`
AMapToData.`preAggregateDDC_RLE(int[] ptr, char[] data, IDictionary td, Dictionary ret, int nCol)`
`final void`
AMapToData.`preAggregateDDC_SDCZ(AMapToData tm, IDictionary td, AOffset tof, Dictionary ret, int nCol)`
PreAggregate into SDCZero dictionary from DDC dictionary.
`void`
AMapToData.`preAggregateDDC_SDCZMultiCol(AMapToData tm, IDictionary td, AOffset tof, double[] v, int nCol)`
`void`
AMapToData.`preAggregateRLE_DDC(int[] ptr, char[] data, IDictionary td, Dictionary ret, int nCol)`
`final void`
AMapToData.`preAggregateSDCZ_DDC(AMapToData tm, IDictionary td, AOffset of, Dictionary ret, int nCol)`
PreAggregate into DDC dictionary from SDCZero dictionary.
`final void`
AMapToData.`preAggregateSDCZ_SDCZ(AMapToData tm, IDictionary td, AOffset tof, AOffset of, Dictionary ret, int nCol)`

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

Fields in org.apache.sysds.runtime.compress.io with type parameters of type IDictionary
Modifier and Type
Field
Description
`List<IDictionary>`
DictWritable.`dicts`

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

Fields in org.apache.sysds.runtime.compress.lib with type parameters of type IDictionary
Modifier and Type
Field
Description
`final List<IDictionary>`
CLALibSeparator.SeparatedGroups.`dicts`
Method parameters in org.apache.sysds.runtime.compress.lib with type arguments of type IDictionary
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.