Examples with IntIntVector com.tencent.angel.ml.math2.vector.IntIntVector used on opensource projects

Example 36 with IntIntVector

use of com.tencent.angel.ml.math2.vector.IntIntVector in project angel by Tencent.

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(IntIntVector v1, IntDummyVector v2, Binary op) {
    IntIntVectorStorage newStorage = (IntIntVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isDense()) {
        int[] resValues = newStorage.getValues();
        int[] v2Indices = v2.getIndices();
        for (int idx : v2Indices) {
            resValues[idx] = op.apply(resValues[idx], 1);
        }
    } else if (v1.isSparse()) {
        int[] v2Indices = v2.getIndices();
        if (((v1.size() + v2.size()) * Constant.intersectionCoeff > Constant.sparseDenseStorageThreshold * v1.getDim())) {
            int[] resValues = newStorage.getValues();
            ObjectIterator<Int2IntMap.Entry> iter = v1.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2IntMap.Entry entry = iter.next();
                newStorage.set(entry.getIntKey(), entry.getIntValue());
            }
            for (int idx : v2Indices) {
                newStorage.set(idx, op.apply(v1.get(idx), 1));
            }
        } else {
            // to avoid multi-rehash
            int capacity = 1 << (32 - Integer.numberOfLeadingZeros((int) (v1.size() / 0.75)));
            if (v1.size() + v2.size() < 1.5 * capacity) {
                int size = v2.size();
                for (int i = 0; i < size; i++) {
                    int idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), 1));
                }
            } else {
                ObjectIterator<Int2IntMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2IntMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getIntValue());
                }
                int size = v2.size();
                for (int i = 0; i < size; i++) {
                    int idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), 1));
                }
            }
        }
    } else {
        // sorted
        int[] v1Indices = v1.getStorage().getIndices();
        int[] v2Indices = v2.getIndices();
        if (!op.isKeepStorage() && ((v1.size() + v2.size()) * Constant.intersectionCoeff > Constant.sortedDenseStorageThreshold * v1.getDim())) {
            int[] v1Values = v1.getStorage().getValues();
            int size = v1.size();
            for (int i = 0; i < size; i++) {
                newStorage.set(v1Indices[i], v1Values[i]);
            }
            size = v2.size();
            for (int i = 0; i < size; i++) {
                int idx = v2Indices[i];
                newStorage.set(idx, op.apply(newStorage.get(idx), 1));
            }
        } else {
            int v1Pointor = 0;
            int v2Pointor = 0;
            int size1 = v1.size();
            int size2 = v2.size();
            int[] v1Values = v1.getStorage().getValues();
            while (v1Pointor < size1 || v2Pointor < size2) {
                if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                    newStorage.set(v1Indices[v1Pointor], op.apply(v1Values[v1Pointor], 1));
                    v1Pointor++;
                    v2Pointor++;
                } else if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] < v2Indices[v2Pointor] || (v1Pointor < size1 && v2Pointor >= size2)) {
                    newStorage.set(v1Indices[v1Pointor], v1Values[v1Pointor]);
                    v1Pointor++;
                } else if (((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] >= v2Indices[v2Pointor]) || (v1Pointor >= size1 && v2Pointor < size2)) {
                    newStorage.set(v2Indices[v2Pointor], op.apply(0, 1));
                    v2Pointor++;
                }
            }
        }
    }
    return new IntIntVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}

Example 37 with IntIntVector

use of com.tencent.angel.ml.math2.vector.IntIntVector in project angel by Tencent.

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(IntLongVector v1, IntIntVector v2, Binary op) {
    IntLongVectorStorage newStorage = (IntLongVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isDense() && v2.isDense()) {
        long[] resValues = newStorage.getValues();
        long[] v1Values = v1.getStorage().getValues();
        int[] v2Values = v2.getStorage().getValues();
        for (int idx = 0; idx < resValues.length; idx++) {
            resValues[idx] = op.apply(v1Values[idx], v2Values[idx]);
        }
    } else if (v1.isDense() && v2.isSparse()) {
        long[] resValues = newStorage.getValues();
        long[] v1Values = v1.getStorage().getValues();
        ObjectIterator<Int2IntMap.Entry> iter = v2.getStorage().entryIterator();
        while (iter.hasNext()) {
            Int2IntMap.Entry entry = iter.next();
            int idx = entry.getIntKey();
            resValues[idx] = op.apply(v1Values[idx], entry.getIntValue());
        }
    } else if (v1.isDense() && v2.isSorted()) {
        long[] resValues = newStorage.getValues();
        long[] v1Values = v1.getStorage().getValues();
        int[] v2Indices = v2.getStorage().getIndices();
        int[] v2Values = v2.getStorage().getValues();
        int size = v2.size();
        for (int i = 0; i < size; i++) {
            int idx = v2Indices[i];
            resValues[idx] = op.apply(v1Values[idx], v2Values[i]);
        }
    } else if (v1.isSparse() && v2.isDense()) {
        if (op.isKeepStorage()) {
            int dim = v1.getDim();
            int[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                for (int i = 0; i < dim; i++) {
                    newStorage.set(i, op.apply(0, v2Values[i]));
                }
                ObjectIterator<Int2LongMap.Entry> iter = v1.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(entry.getLongValue(), v2Values[idx]));
                }
            } else {
                for (int i = 0; i < dim; i++) {
                    if (v1.getStorage().hasKey(i)) {
                        newStorage.set(i, op.apply(v1.get(i), v2Values[i]));
                    } else {
                        newStorage.set(i, op.apply(0, v2Values[i]));
                    }
                }
            }
        } else {
            long[] resValues = newStorage.getValues();
            int[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(0, v2Values[i]);
                }
                ObjectIterator<Int2LongMap.Entry> iter = v1.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    resValues[idx] = op.apply(entry.getLongValue(), v2Values[idx]);
                }
            } else {
                for (int i = 0; i < resValues.length; i++) {
                    if (v1.getStorage().hasKey(i)) {
                        resValues[i] = op.apply(v1.get(i), v2Values[i]);
                    } else {
                        resValues[i] = op.apply(0, v2Values[i]);
                    }
                }
            }
        }
    } else if (v1.isSorted() && v2.isDense()) {
        if (op.isKeepStorage()) {
            int dim = v1.getDim();
            int[] resIndices = newStorage.getIndices();
            long[] resValues = newStorage.getValues();
            int[] v2Values = v2.getStorage().getValues();
            int[] v1Indices = v1.getStorage().getIndices();
            long[] v1Values = v1.getStorage().getValues();
            for (int i = 0; i < dim; i++) {
                resIndices[i] = i;
                resValues[i] = op.apply(0, v2Values[i]);
            }
            int size = v1.size();
            for (int i = 0; i < size; i++) {
                int idx = v1Indices[i];
                resValues[idx] = op.apply(v1Values[i], v2Values[idx]);
            }
        } else {
            long[] resValues = newStorage.getValues();
            int[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                int[] v1Indices = v1.getStorage().getIndices();
                long[] v1Values = v1.getStorage().getValues();
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(0, v2Values[i]);
                }
                int size = v1.size();
                for (int i = 0; i < size; i++) {
                    int idx = v1Indices[i];
                    resValues[idx] = op.apply(v1Values[i], v2Values[idx]);
                }
            } else {
                IntLongVectorStorage v1Storage = v1.getStorage();
                for (int i = 0; i < resValues.length; i++) {
                    if (v1Storage.hasKey(i)) {
                        resValues[i] = op.apply(v1.get(i), v2Values[i]);
                    } else {
                        resValues[i] = op.apply(0, v2Values[i]);
                    }
                }
            }
        }
    } else if (v1.isSparse() && v2.isSparse()) {
        int v1Size = v1.size();
        int v2Size = v2.size();
        if (v1Size >= v2Size * Constant.sparseThreshold && (v1Size + v2Size) * Constant.intersectionCoeff <= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss the indices of v2 maybe is a subset of v1, or overlap is very large
            ObjectIterator<Int2IntMap.Entry> iter = v2.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2IntMap.Entry entry = iter.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss dense storage is more efficient
            ObjectIterator<Int2LongMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2LongMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, entry.getLongValue());
            }
            ObjectIterator<Int2IntMap.Entry> iter2 = v2.getStorage().entryIterator();
            while (iter2.hasNext()) {
                Int2IntMap.Entry entry = iter2.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
            }
        } else {
            // to avoid multi-rehash
            int capacity = 1 << (32 - Integer.numberOfLeadingZeros((int) (v1.size() / 0.75)));
            if (v1.size() + v2.size() <= 1.5 * capacity) {
                // no rehashor one onle rehash is required, nothing to optimization
                ObjectIterator<Int2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2IntMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
                }
            } else {
                // multi-rehash
                ObjectIterator<Int2LongMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2LongMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getLongValue());
                }
                ObjectIterator<Int2IntMap.Entry> iter2 = v2.getStorage().entryIterator();
                while (iter2.hasNext()) {
                    Int2IntMap.Entry entry = iter2.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
                }
            }
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        int v1Size = v1.size();
        int v2Size = v2.size();
        if (v1Size >= v2Size * Constant.sparseThreshold && (v1Size + v2Size) * Constant.intersectionCoeff <= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss the indices of v2 maybe is a subset of v1, or overlap is very large
            int[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            for (int i = 0; i < v2.size(); i++) {
                int idx = v2Indices[i];
                newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            ObjectIterator<Int2LongMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2LongMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, entry.getLongValue());
            }
            int[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            int size = v2.size();
            for (int i = 0; i < size; i++) {
                int idx = v2Indices[i];
                newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
            }
        } else {
            // to avoid multi-rehash
            int capacity = 1 << (32 - Integer.numberOfLeadingZeros((int) (v1.size() / 0.75)));
            if (v1.size() + v2.size() <= 1.5 * capacity) {
                int[] v2Indices = v2.getStorage().getIndices();
                int[] v2Values = v2.getStorage().getValues();
                for (int i = 0; i < v2.size(); i++) {
                    int idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            } else {
                ObjectIterator<Int2LongMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2LongMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getLongValue());
                }
                int[] v2Indices = v2.getStorage().getIndices();
                int[] v2Values = v2.getStorage().getValues();
                int size = v2.size();
                for (int i = 0; i < size; i++) {
                    int idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        int v1Size = v1.size();
        int v2Size = v2.size();
        if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                int[] v1Indices = v1.getStorage().getIndices();
                int[] idxiter = v2.getStorage().indexIterator().toIntArray();
                int[] indices = new int[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                IntAVLTreeSet avl = new IntAVLTreeSet(indices);
                IntBidirectionalIterator iter = avl.iterator();
                long[] values = new long[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    int idx = iter.nextInt();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new IntLongSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                int[] v1Indices = v1.getStorage().getIndices();
                long[] v1Values = v1.getStorage().getValues();
                int size = v1.size();
                for (int i = 0; i < size; i++) {
                    int idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Int2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2IntMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getIntValue()));
                }
            }
        } else {
            if (op.isKeepStorage()) {
                int[] v1Indices = v1.getStorage().getIndices();
                int[] idxiter = v2.getStorage().indexIterator().toIntArray();
                int[] indices = new int[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                IntAVLTreeSet avl = new IntAVLTreeSet(indices);
                IntBidirectionalIterator iter = avl.iterator();
                long[] values = new long[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    int idx = iter.nextInt();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new IntLongSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                int[] v1Indices = v1.getStorage().getIndices();
                long[] v1Values = v1.getStorage().getValues();
                int size = v1.size();
                for (int i = 0; i < size; i++) {
                    int idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Int2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2IntMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getIntValue()));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        int v1Pointor = 0;
        int v2Pointor = 0;
        int size1 = v1.size();
        int size2 = v2.size();
        int[] v1Indices = v1.getStorage().getIndices();
        long[] v1Values = v1.getStorage().getValues();
        int[] v2Indices = v2.getStorage().getIndices();
        int[] v2Values = v2.getStorage().getValues();
        if ((size1 + size2) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                // sorted
                int[] resIndices = newStorage.getIndices();
                long[] resValues = newStorage.getValues();
                int global = 0;
                while (v1Pointor < size1 && v2Pointor < size2) {
                    if (v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        resIndices[global] = v1Indices[v1Pointor];
                        resValues[global] = op.apply(v1Values[v1Pointor], v2Values[v2Pointor]);
                        global++;
                        v1Pointor++;
                        v2Pointor++;
                    } else if (v1Indices[v1Pointor] < v2Indices[v2Pointor]) {
                        resIndices[global] = v1Indices[v1Pointor];
                        resValues[global] = v1Values[v1Pointor];
                        global++;
                        v1Pointor++;
                    } else {
                        // v1Indices[v1Pointor] > v2Indices[v2Pointor]
                        resIndices[global] = v2Indices[v2Pointor];
                        resValues[global] = op.apply(0, v2Values[v2Pointor]);
                        global++;
                        v2Pointor++;
                    }
                }
            } else {
                // dense
                while (v1Pointor < size1 || v2Pointor < size2) {
                    if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        newStorage.set(v1Indices[v1Pointor], op.apply(v1Values[v1Pointor], v2Values[v2Pointor]));
                        v1Pointor++;
                        v2Pointor++;
                    } else if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] < v2Indices[v2Pointor] || (v1Pointor < size1 && v2Pointor >= size2)) {
                        newStorage.set(v1Indices[v1Pointor], v1Values[v1Pointor]);
                        v1Pointor++;
                    } else if (((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] >= v2Indices[v2Pointor]) || (v1Pointor >= size1 && v2Pointor < size2)) {
                        newStorage.set(v2Indices[v2Pointor], op.apply(0, v2Values[v2Pointor]));
                        v2Pointor++;
                    }
                }
            }
        } else {
            if (op.isKeepStorage()) {
                int[] resIndices = newStorage.getIndices();
                long[] resValues = newStorage.getValues();
                int globalPointor = 0;
                while (v1Pointor < size1 && v2Pointor < size2) {
                    if (v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        resIndices[globalPointor] = v1Indices[v1Pointor];
                        resValues[globalPointor] = op.apply(v1Values[v1Pointor], v2Values[v2Pointor]);
                        v1Pointor++;
                        v2Pointor++;
                        globalPointor++;
                    } else if (v1Indices[v1Pointor] < v2Indices[v2Pointor]) {
                        resIndices[globalPointor] = v1Indices[v1Pointor];
                        resValues[globalPointor] = v1Values[v1Pointor];
                        v1Pointor++;
                        globalPointor++;
                    } else {
                        // v1Indices[v1Pointor] > v2Indices[v2Pointor]
                        resIndices[globalPointor] = v2Indices[v2Pointor];
                        resValues[globalPointor] = op.apply(0, v2Values[v2Pointor]);
                        v2Pointor++;
                        globalPointor++;
                    }
                }
            } else {
                while (v1Pointor < size1 || v2Pointor < size2) {
                    if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        newStorage.set(v1Indices[v1Pointor], op.apply(v1Values[v1Pointor], v2Values[v2Pointor]));
                        v1Pointor++;
                        v2Pointor++;
                    } else if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] < v2Indices[v2Pointor] || (v1Pointor < size1 && v2Pointor >= size2)) {
                        newStorage.set(v1Indices[v1Pointor], v1Values[v1Pointor]);
                        v1Pointor++;
                    } else if (((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] >= v2Indices[v2Pointor]) || (v1Pointor >= size1 && v2Pointor < size2)) {
                        newStorage.set(v2Indices[v2Pointor], op.apply(0, v2Values[v2Pointor]));
                        v2Pointor++;
                    }
                }
            }
        }
    } else {
        throw new AngelException("The operation is not support!");
    }
    return new IntLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}

Example 38 with IntIntVector

use of com.tencent.angel.ml.math2.vector.IntIntVector in project angel by Tencent.

the class SimpleUnaryExecutor method apply.

private static Vector apply(IntIntVector v1, Unary op) {
    IntIntVector res;
    if (op.isOrigin() || v1.isDense()) {
        if (!op.isInplace()) {
            res = v1.copy();
        } else {
            res = v1;
        }
        if (v1.isDense()) {
            int[] values = res.getStorage().getValues();
            for (int i = 0; i < values.length; i++) {
                values[i] = op.apply(values[i]);
            }
        } else if (v1.isSparse()) {
            ObjectIterator<Int2IntMap.Entry> iter = res.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2IntMap.Entry entry = iter.next();
                entry.setValue(op.apply(entry.getIntValue()));
            }
        } else if (v1.isSorted()) {
            int[] values = res.getStorage().getValues();
            for (int i = 0; i < v1.size(); i++) {
                values[i] = op.apply(values[i]);
            }
        } else {
            throw new AngelException("The operation is not support!");
        }
    } else {
        IntIntVectorStorage newstorage = v1.getStorage().emptyDense();
        IntIntVectorStorage storage = v1.getStorage();
        int[] values = newstorage.getValues();
        int tmp = op.apply((int) 0);
        int dim = v1.getDim();
        for (int i = 0; i < dim; i++) {
            values[i] = tmp;
        }
        if (v1.isSparse()) {
            ObjectIterator<Int2IntMap.Entry> iter = storage.entryIterator();
            while (iter.hasNext()) {
                Int2IntMap.Entry entry = iter.next();
                values[entry.getIntKey()] = op.apply(entry.getIntValue());
            }
        } else {
            // sort
            int[] idxs = storage.getIndices();
            int[] v1Values = storage.getValues();
            for (int k = 0; k < idxs.length; k++) {
                values[idxs[k]] = op.apply(v1Values[k]);
            }
        }
        if (op.isInplace()) {
            v1.setStorage(newstorage);
            res = v1;
        } else {
            res = new IntIntVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newstorage);
        }
    }
    return res;
}

Example 39 with IntIntVector

use of com.tencent.angel.ml.math2.vector.IntIntVector in project angel by Tencent.

the class RangeRouterUtils method splitIntIntVector.

public static KeyValuePart[] splitIntIntVector(MatrixMeta matrixMeta, IntIntVector vector) {
    IntIntVectorStorage storage = vector.getStorage();
    if (storage.isSparse()) {
        // Get keys and values
        IntIntSparseVectorStorage sparseStorage = (IntIntSparseVectorStorage) storage;
        int[] keys = sparseStorage.getIndices();
        int[] values = sparseStorage.getValues();
        return split(matrixMeta, vector.getRowId(), keys, values, false);
    } else if (storage.isDense()) {
        // Get values
        IntIntDenseVectorStorage denseStorage = (IntIntDenseVectorStorage) storage;
        int[] values = denseStorage.getValues();
        return split(matrixMeta, vector.getRowId(), values);
    } else {
        // Key and value array pair
        IntIntSortedVectorStorage sortStorage = (IntIntSortedVectorStorage) storage;
        int[] keys = sortStorage.getIndices();
        int[] values = sortStorage.getValues();
        return split(matrixMeta, vector.getRowId(), keys, values, true);
    }
}

Example 40 with IntIntVector

use of com.tencent.angel.ml.math2.vector.IntIntVector in project angel by Tencent.

the class HashRouterUtils method splitIntIntVector.

public static void splitIntIntVector(KeyHash hasher, MatrixMeta matrixMeta, IntIntVector vector, KeyValuePart[] dataParts) {
    int dataPartNum = dataParts.length;
    int dataPartNumMinus1 = dataPartNum - 1;
    if (isPow2(dataPartNum)) {
        IntIntVectorStorage storage = vector.getStorage();
        if (storage.isSparse()) {
            // Use iterator
            IntIntSparseVectorStorage sparseStorage = (IntIntSparseVectorStorage) storage;
            ObjectIterator<Int2IntMap.Entry> iter = sparseStorage.entryIterator();
            while (iter.hasNext()) {
                Int2IntMap.Entry keyValue = iter.next();
                int partId = computeHashCode(hasher, keyValue.getIntKey()) & dataPartNumMinus1;
                ((HashIntKeysIntValuesPart) dataParts[partId]).add(keyValue.getIntKey(), keyValue.getIntValue());
            }
        } else if (storage.isDense()) {
            // Get values
            IntIntDenseVectorStorage denseStorage = (IntIntDenseVectorStorage) storage;
            int[] values = denseStorage.getValues();
            for (int i = 0; i < values.length; i++) {
                int partId = computeHashCode(hasher, i) & dataPartNumMinus1;
                ((HashIntKeysIntValuesPart) dataParts[partId]).add(i, values[i]);
            }
        } else {
            // Key and value array pair
            IntIntSortedVectorStorage sortStorage = (IntIntSortedVectorStorage) storage;
            int[] keys = sortStorage.getIndices();
            int[] values = sortStorage.getValues();
            for (int i = 0; i < keys.length; i++) {
                int partId = computeHashCode(hasher, keys[i]) & dataPartNumMinus1;
                ((HashIntKeysIntValuesPart) dataParts[partId]).add(keys[i], values[i]);
            }
        }
    } else {
        IntIntVectorStorage storage = vector.getStorage();
        if (storage.isSparse()) {
            // Use iterator
            IntIntSparseVectorStorage sparseStorage = (IntIntSparseVectorStorage) storage;
            ObjectIterator<Int2IntMap.Entry> iter = sparseStorage.entryIterator();
            while (iter.hasNext()) {
                Int2IntMap.Entry keyValue = iter.next();
                int partId = computeHashCode(hasher, keyValue.getIntKey()) % dataPartNum;
                ((HashIntKeysIntValuesPart) dataParts[partId]).add(keyValue.getIntKey(), keyValue.getIntValue());
            }
        } else if (storage.isDense()) {
            // Get values
            IntIntDenseVectorStorage denseStorage = (IntIntDenseVectorStorage) storage;
            int[] values = denseStorage.getValues();
            for (int i = 0; i < values.length; i++) {
                int partId = computeHashCode(hasher, i) % dataPartNum;
                ((HashIntKeysIntValuesPart) dataParts[partId]).add(i, values[i]);
            }
        } else {
            // Key and value array pair
            IntIntSortedVectorStorage sortStorage = (IntIntSortedVectorStorage) storage;
            int[] keys = sortStorage.getIndices();
            int[] values = sortStorage.getValues();
            for (int i = 0; i < keys.length; i++) {
                int partId = computeHashCode(hasher, keys[i]) % dataPartNum;
                ((HashIntKeysIntValuesPart) dataParts[partId]).add(keys[i], values[i]);
            }
        }
    }
}