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

Example 36 with IntDummyVector

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

the class MixedBinaryOutZAExecutor method apply.

private static Vector apply(CompIntDoubleVector v1, IntDummyVector v2, Binary op) {
    IntDoubleVector[] parts = v1.getPartitions();
    Storage[] resParts = StorageSwitch.applyComp(v1, v2, op);
    if (v1.size() > v2.size()) {
        int subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
        int[] v2Indices = v2.getIndices();
        for (int i = 0; i < v2Indices.length; i++) {
            int idx = v2Indices[i];
            int pidx = (int) (idx / subDim);
            int subidx = idx % subDim;
            if (parts[pidx].hasKey(subidx)) {
                ((IntDoubleVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), 1));
            }
        }
    } else {
        int base = 0;
        for (int i = 0; i < parts.length; i++) {
            IntDoubleVector part = parts[i];
            IntDoubleVectorStorage resPart = (IntDoubleVectorStorage) resParts[i];
            if (part.isDense()) {
                double[] partValues = part.getStorage().getValues();
                double[] resPartValues = resPart.getValues();
                for (int j = 0; j < partValues.length; j++) {
                    if (v2.hasKey(j + base)) {
                        resPartValues[j] = op.apply(partValues[j], v2.get(j + base));
                    }
                }
            } else if (part.isSparse()) {
                ObjectIterator<Int2DoubleMap.Entry> piter = part.getStorage().entryIterator();
                while (piter.hasNext()) {
                    Int2DoubleMap.Entry entry = piter.next();
                    int idx = entry.getIntKey();
                    if (v2.hasKey(idx + base)) {
                        resPart.set(idx, op.apply(entry.getDoubleValue(), v2.get(idx + base)));
                    }
                }
            } else {
                // sorted
                if (op.isKeepStorage()) {
                    int[] partIndices = part.getStorage().getIndices();
                    double[] partValues = part.getStorage().getValues();
                    int[] resPartIndices = resPart.getIndices();
                    double[] resPartValues = resPart.getValues();
                    for (int j = 0; j < partIndices.length; j++) {
                        int idx = partIndices[j];
                        if (v2.hasKey(idx + base)) {
                            resPartIndices[j] = idx;
                            resPartValues[j] = op.apply(partValues[j], v2.get(idx + base));
                        }
                    }
                } else {
                    int[] partIndices = part.getStorage().getIndices();
                    double[] partValues = part.getStorage().getValues();
                    for (int j = 0; j < partIndices.length; j++) {
                        int idx = partIndices[j];
                        if (v2.hasKey(idx + base)) {
                            resPart.set(idx, op.apply(partValues[j], v2.get(idx + base)));
                        }
                    }
                }
            }
            base += part.getDim();
        }
    }
    IntDoubleVector[] res = new IntDoubleVector[parts.length];
    int i = 0;
    for (IntDoubleVector part : parts) {
        res[i] = new IntDoubleVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntDoubleVectorStorage) resParts[i]);
        i++;
    }
    return new CompIntDoubleVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), res, v1.getSubDim());
}

Example 37 with IntDummyVector

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

the class MixedBinaryOutZAExecutor method apply.

private static Vector apply(CompIntFloatVector v1, IntDummyVector v2, Binary op) {
    IntFloatVector[] parts = v1.getPartitions();
    Storage[] resParts = StorageSwitch.applyComp(v1, v2, op);
    if (v1.size() > v2.size()) {
        int subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
        int[] v2Indices = v2.getIndices();
        for (int i = 0; i < v2Indices.length; i++) {
            int idx = v2Indices[i];
            int pidx = (int) (idx / subDim);
            int subidx = idx % subDim;
            if (parts[pidx].hasKey(subidx)) {
                ((IntFloatVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), 1));
            }
        }
    } else {
        int base = 0;
        for (int i = 0; i < parts.length; i++) {
            IntFloatVector part = parts[i];
            IntFloatVectorStorage resPart = (IntFloatVectorStorage) resParts[i];
            if (part.isDense()) {
                float[] partValues = part.getStorage().getValues();
                float[] resPartValues = resPart.getValues();
                for (int j = 0; j < partValues.length; j++) {
                    if (v2.hasKey(j + base)) {
                        resPartValues[j] = op.apply(partValues[j], v2.get(j + base));
                    }
                }
            } else if (part.isSparse()) {
                ObjectIterator<Int2FloatMap.Entry> piter = part.getStorage().entryIterator();
                while (piter.hasNext()) {
                    Int2FloatMap.Entry entry = piter.next();
                    int idx = entry.getIntKey();
                    if (v2.hasKey(idx + base)) {
                        resPart.set(idx, op.apply(entry.getFloatValue(), v2.get(idx + base)));
                    }
                }
            } else {
                // sorted
                if (op.isKeepStorage()) {
                    int[] partIndices = part.getStorage().getIndices();
                    float[] partValues = part.getStorage().getValues();
                    int[] resPartIndices = resPart.getIndices();
                    float[] resPartValues = resPart.getValues();
                    for (int j = 0; j < partIndices.length; j++) {
                        int idx = partIndices[j];
                        if (v2.hasKey(idx + base)) {
                            resPartIndices[j] = idx;
                            resPartValues[j] = op.apply(partValues[j], v2.get(idx + base));
                        }
                    }
                } else {
                    int[] partIndices = part.getStorage().getIndices();
                    float[] partValues = part.getStorage().getValues();
                    for (int j = 0; j < partIndices.length; j++) {
                        int idx = partIndices[j];
                        if (v2.hasKey(idx + base)) {
                            resPart.set(idx, op.apply(partValues[j], v2.get(idx + base)));
                        }
                    }
                }
            }
            base += part.getDim();
        }
    }
    IntFloatVector[] res = new IntFloatVector[parts.length];
    int i = 0;
    for (IntFloatVector part : parts) {
        res[i] = new IntFloatVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntFloatVectorStorage) resParts[i]);
        i++;
    }
    return new CompIntFloatVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), res, v1.getSubDim());
}

Example 38 with IntDummyVector

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

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(IntDoubleVector v1, IntDummyVector v2, Binary op) {
    IntDoubleVectorStorage newStorage = (IntDoubleVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isDense()) {
        double[] 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())) {
            double[] resValues = newStorage.getValues();
            ObjectIterator<Int2DoubleMap.Entry> iter = v1.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2DoubleMap.Entry entry = iter.next();
                newStorage.set(entry.getIntKey(), entry.getDoubleValue());
            }
            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<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2DoubleMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getDoubleValue());
                }
                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())) {
            double[] 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();
            double[] 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 IntDoubleVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}

Example 39 with IntDummyVector

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

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(IntLongVector v1, IntDummyVector v2, Binary op) {
    IntLongVectorStorage newStorage = (IntLongVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isDense()) {
        long[] 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())) {
            long[] resValues = newStorage.getValues();
            ObjectIterator<Int2LongMap.Entry> iter = v1.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2LongMap.Entry entry = iter.next();
                newStorage.set(entry.getIntKey(), entry.getLongValue());
            }
            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<Int2LongMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2LongMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getLongValue());
                }
                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())) {
            long[] 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();
            long[] 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 IntLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}

Example 40 with IntDummyVector

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

the class SimpleBinaryOutAllExecutor method apply.

public static Vector apply(IntIntVector v1, IntDummyVector v2, Binary op) {
    IntIntVector res;
    if (v1.isDense()) {
        res = v1.copy();
        int[] resValues = res.getStorage().getValues();
        for (int i = 0; i < v1.getDim(); i++) {
            resValues[i] = op.apply(resValues[i], v2.get(i));
        }
    } else if (v1.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntIntVectorStorage newStorage = v1.getStorage().emptyDense();
            int[] resValues = newStorage.getValues();
            ObjectIterator<Int2IntMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2IntMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                resValues[idx] = entry.getIntValue();
            }
            for (int i = 0; i < v1.getDim(); i++) {
                resValues[i] = op.apply(resValues[i], v2.get(i));
            }
            res = new IntIntVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
        }
    } else {
        // sorted
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntIntVectorStorage newStorage = v1.getStorage().emptyDense();
            int[] resValues = newStorage.getValues();
            int[] v1Indices = v1.getStorage().getIndices();
            int[] v1Values = v1.getStorage().getValues();
            int size = v1.size();
            for (int i = 0; i < size; i++) {
                int idx = v1Indices[i];
                resValues[idx] = v1Values[i];
            }
            for (int i = 0; i < v1.getDim(); i++) {
                resValues[i] = op.apply(resValues[i], v2.get(i));
            }
            res = new IntIntVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
        }
    }
    return res;
}