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

Example 71 with IntLongVector

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

the class MixedBinaryOutZAExecutor method apply.

private static Vector apply(CompIntLongVector v1, IntIntVector v2, Binary op) {
    IntLongVector[] parts = v1.getPartitions();
    Storage[] resParts = StorageSwitch.applyComp(v1, v2, op);
    if (v2.isDense()) {
        int base = 0;
        int[] v2Values = v2.getStorage().getValues();
        for (int i = 0; i < parts.length; i++) {
            IntLongVector part = parts[i];
            IntLongVectorStorage resPart = (IntLongVectorStorage) resParts[i];
            if (part.isDense()) {
                long[] resPartValues = resPart.getValues();
                long[] partValues = part.getStorage().getValues();
                for (int j = 0; j < resPartValues.length; j++) {
                    resPartValues[j] = op.apply(partValues[j], v2Values[base + j]);
                }
            } else if (part.isSparse()) {
                ObjectIterator<Int2LongMap.Entry> iter = part.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    resPart.set(idx, op.apply(entry.getLongValue(), v2Values[idx + base]));
                }
            } else {
                // sorted
                if (op.isKeepStorage()) {
                    int[] resPartIndices = resPart.getIndices();
                    long[] resPartValues = resPart.getValues();
                    int[] partIndices = part.getStorage().getIndices();
                    long[] partValues = part.getStorage().getValues();
                    for (int j = 0; j < partIndices.length; j++) {
                        int idx = partIndices[j];
                        resPartIndices[j] = idx;
                        resPartValues[j] = op.apply(partValues[j], v2Values[idx + base]);
                    }
                } else {
                    int[] partIndices = part.getStorage().getIndices();
                    long[] partValues = part.getStorage().getValues();
                    for (int j = 0; j < partIndices.length; j++) {
                        int idx = partIndices[j];
                        resPart.set(idx, op.apply(partValues[j], v2Values[idx + base]));
                    }
                }
            }
            base += part.getDim();
        }
    } else if (v2.isSparse()) {
        ObjectIterator<Int2IntMap.Entry> iter = v2.getStorage().entryIterator();
        if (v1.size() > v2.size()) {
            int subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
            while (iter.hasNext()) {
                Int2IntMap.Entry entry = iter.next();
                int idx = entry.getIntKey();
                int pidx = (int) (idx / subDim);
                int subidx = idx % subDim;
                if (parts[pidx].hasKey(subidx)) {
                    ((IntLongVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), entry.getIntValue()));
                }
            }
        } else {
            int base = 0;
            for (int i = 0; i < parts.length; i++) {
                IntLongVector part = parts[i];
                IntLongVectorStorage resPart = (IntLongVectorStorage) resParts[i];
                if (part.isDense()) {
                    long[] partValues = part.getStorage().getValues();
                    long[] 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<Int2LongMap.Entry> piter = part.getStorage().entryIterator();
                    while (piter.hasNext()) {
                        Int2LongMap.Entry entry = piter.next();
                        int idx = entry.getIntKey();
                        if (v2.hasKey(idx + base)) {
                            resPart.set(idx, op.apply(entry.getLongValue(), v2.get(idx + base)));
                        }
                    }
                } else {
                    // sorted
                    if (op.isKeepStorage()) {
                        int[] partIndices = part.getStorage().getIndices();
                        long[] partValues = part.getStorage().getValues();
                        int[] resPartIndices = resPart.getIndices();
                        long[] 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();
                        long[] 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();
            }
        }
    } else {
        // sorted
        if (v1.size() > v2.size()) {
            int subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
            int[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            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)) {
                    ((IntLongVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), v2Values[i]));
                }
            }
        } else {
            int base = 0;
            for (int i = 0; i < parts.length; i++) {
                IntLongVector part = parts[i];
                IntLongVectorStorage resPart = (IntLongVectorStorage) resParts[i];
                if (part.isDense()) {
                    long[] partValues = part.getStorage().getValues();
                    long[] 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<Int2LongMap.Entry> piter = part.getStorage().entryIterator();
                    while (piter.hasNext()) {
                        Int2LongMap.Entry entry = piter.next();
                        int idx = entry.getIntKey();
                        if (v2.hasKey(idx + base)) {
                            resPart.set(idx, op.apply(entry.getLongValue(), v2.get(idx + base)));
                        }
                    }
                } else {
                    // sorted
                    if (op.isKeepStorage()) {
                        int[] partIndices = part.getStorage().getIndices();
                        long[] partValues = part.getStorage().getValues();
                        int[] resPartIndices = resPart.getIndices();
                        long[] 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();
                        long[] 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();
            }
        }
    }
    IntLongVector[] res = new IntLongVector[parts.length];
    int i = 0;
    for (IntLongVector part : parts) {
        res[i] = new IntLongVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntLongVectorStorage) resParts[i]);
        i++;
    }
    return new CompIntLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), res, v1.getSubDim());
}

Example 72 with IntLongVector

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

the class MixedBinaryOutAllExecutor method apply.

private static Vector apply(CompIntLongVector v1, IntDummyVector v2, Binary op) {
    IntLongVector[] parts = v1.getPartitions();
    Storage[] resParts = StorageSwitch.applyComp(v1, v2, op);
    if (!op.isKeepStorage()) {
        for (int i = 0; i < parts.length; i++) {
            if (parts[i].getStorage() instanceof IntLongSortedVectorStorage) {
                resParts[i] = new IntLongSparseVectorStorage(parts[i].getDim(), parts[i].getStorage().getIndices(), parts[i].getStorage().getValues());
            }
        }
    }
    int subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
    for (int i = 0; i < v1.getDim(); i++) {
        int pidx = (int) (i / subDim);
        int subidx = i % subDim;
        ((IntLongVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), v2.get(i)));
    }
    IntLongVector[] res = new IntLongVector[parts.length];
    int i = 0;
    for (IntLongVector part : parts) {
        res[i] = new IntLongVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntLongVectorStorage) resParts[i]);
        i++;
    }
    return new CompIntLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), res, v1.getSubDim());
}

Example 73 with IntLongVector

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

the class MixedBinaryOutAllExecutor method apply.

private static Vector apply(CompIntLongVector v1, IntIntVector v2, Binary op) {
    IntLongVector[] parts = v1.getPartitions();
    Storage[] resParts = StorageSwitch.applyComp(v1, v2, op);
    if (v2.isDense()) {
        int[] v2Values = v2.getStorage().getValues();
        int base = 0, k = 0;
        for (IntLongVector part : parts) {
            IntLongVectorStorage resPart = (IntLongVectorStorage) resParts[k];
            if (part.isDense()) {
                long[] partValue = part.getStorage().getValues();
                long[] resPartValues = resPart.getValues();
                for (int i = 0; i < partValue.length; i++) {
                    int idx = i;
                    resPartValues[i] = op.apply(partValue[i], v2Values[idx + base]);
                }
            } else if (part.isSparse()) {
                if (part.size() < Constant.denseLoopThreshold * part.getDim()) {
                    for (int i = 0; i < part.getDim(); i++) {
                        resPart.set(i, op.apply(0, v2Values[i + base]));
                    }
                    ObjectIterator<Int2LongMap.Entry> iter = part.getStorage().entryIterator();
                    while (iter.hasNext()) {
                        Int2LongMap.Entry entry = iter.next();
                        int idx = entry.getIntKey();
                        resPart.set(idx, op.apply(entry.getLongValue(), v2Values[idx + base]));
                    }
                } else {
                    for (int i = 0; i < resPart.size(); i++) {
                        if (part.getStorage().hasKey(i)) {
                            resPart.set(i, op.apply(part.get(i), v2Values[i + base]));
                        } else {
                            resPart.set(i, op.apply(0, v2Values[i + base]));
                        }
                    }
                }
            } else {
                // sorted
                if (op.isKeepStorage()) {
                    int[] resPartIndices = resPart.getIndices();
                    long[] resPartValues = resPart.getValues();
                    if (part.size() < Constant.denseLoopThreshold * part.getDim()) {
                        int[] partIndices = part.getStorage().getIndices();
                        long[] partValues = part.getStorage().getValues();
                        for (int i = 0; i < part.getDim(); i++) {
                            resPartIndices[i] = i;
                            resPartValues[i] = op.apply(0, v2Values[i + base]);
                        }
                        int size = part.size();
                        for (int i = 0; i < size; i++) {
                            int idx = partIndices[i];
                            resPartValues[idx] = op.apply(partValues[i], v2Values[idx + base]);
                        }
                    } else {
                        IntLongVectorStorage partStorage = part.getStorage();
                        for (int i = 0; i < resPartValues.length; i++) {
                            if (partStorage.hasKey(i)) {
                                resPartIndices[i] = i;
                                resPartValues[i] = op.apply(partStorage.get(i), v2Values[i + base]);
                            } else {
                                resPartIndices[i] = i;
                                resPartValues[i] = op.apply(0, v2Values[i + base]);
                            }
                        }
                    }
                } else {
                    long[] resPartValues = resPart.getValues();
                    if (part.size() < Constant.denseLoopThreshold * part.getDim()) {
                        int[] partIndices = part.getStorage().getIndices();
                        long[] partValues = part.getStorage().getValues();
                        for (int i = 0; i < part.getDim(); i++) {
                            resPartValues[i] = op.apply(0, v2Values[i + base]);
                        }
                        int size = part.size();
                        for (int i = 0; i < size; i++) {
                            int idx = partIndices[i];
                            resPartValues[idx] = op.apply(partValues[i], v2Values[idx + base]);
                        }
                    } else {
                        IntLongVectorStorage partStorage = part.getStorage();
                        for (int i = 0; i < resPartValues.length; i++) {
                            if (partStorage.hasKey(i)) {
                                resPartValues[i] = op.apply(partStorage.get(i), v2Values[i + base]);
                            } else {
                                resPartValues[i] = op.apply(0, v2Values[i + base]);
                            }
                        }
                    }
                }
            }
            base += part.getDim();
            k++;
        }
    } else {
        if (!op.isKeepStorage()) {
            for (int i = 0; i < parts.length; i++) {
                if (parts[i].getStorage() instanceof IntLongSortedVectorStorage) {
                    resParts[i] = new IntLongSparseVectorStorage(parts[i].getDim(), parts[i].getStorage().getIndices(), parts[i].getStorage().getValues());
                }
            }
        }
        int subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
        for (int i = 0; i < v1.getDim(); i++) {
            int pidx = (int) (i / subDim);
            int subidx = i % subDim;
            if (v2.getStorage().hasKey(i)) {
                ((IntLongVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), v2.get(i)));
            } else {
                ((IntLongVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), 0));
            }
        }
    }
    IntLongVector[] res = new IntLongVector[parts.length];
    int i = 0;
    for (IntLongVector part : parts) {
        res[i] = new IntLongVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntLongVectorStorage) resParts[i]);
        i++;
    }
    return new CompIntLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), res, v1.getSubDim());
}

Example 74 with IntLongVector

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

the class SimpleBinaryInAllExecutor method apply.

public static Vector apply(IntDoubleVector v1, IntLongVector v2, Binary op) {
    if (v1.isDense() && v2.isDense()) {
        double[] resValues = v1.getStorage().getValues();
        long[] v2Values = v2.getStorage().getValues();
        for (int idx = 0; idx < resValues.length; idx++) {
            resValues[idx] = op.apply(resValues[idx], v2Values[idx]);
        }
    } else if (v1.isDense() && v2.isSparse()) {
        double[] resValues = v1.getStorage().getValues();
        if (v2.size() < Constant.denseLoopThreshold * v2.getDim()) {
            for (int i = 0; i < resValues.length; i++) {
                resValues[i] = op.apply(resValues[i], 0);
            }
            ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2LongMap.Entry entry = iter.next();
                int idx = entry.getIntKey();
                resValues[idx] = op.apply(v1.get(idx), entry.getLongValue());
            }
        } else {
            IntLongVectorStorage v2Storage = v2.getStorage();
            for (int i = 0; i < resValues.length; i++) {
                if (v2Storage.hasKey(i)) {
                    resValues[i] = op.apply(resValues[i], v2.get(i));
                } else {
                    resValues[i] = op.apply(resValues[i], 0);
                }
            }
        }
    } else if (v1.isDense() && v2.isSorted()) {
        double[] resValues = v1.getStorage().getValues();
        if (v2.size() < Constant.denseLoopThreshold * v2.getDim()) {
            int[] v2Indices = v2.getStorage().getIndices();
            long[] v2Values = v2.getStorage().getValues();
            for (int i = 0; i < resValues.length; i++) {
                resValues[i] = op.apply(resValues[i], 0);
            }
            int size = v2.size();
            for (int i = 0; i < size; i++) {
                int idx = v2Indices[i];
                resValues[idx] = op.apply(v1.get(idx), v2Values[i]);
            }
        } else {
            IntLongVectorStorage v2Storage = v2.getStorage();
            for (int i = 0; i < resValues.length; i++) {
                if (v2Storage.hasKey(i)) {
                    resValues[i] = op.apply(resValues[i], v2.get(i));
                } else {
                    resValues[i] = op.apply(resValues[i], 0);
                }
            }
        }
    } else if (v1.isSparse() && v2.isDense()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntDoubleVectorStorage newStorage = v1.getStorage().emptyDense();
            double[] resValues = newStorage.getValues();
            long[] 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<Int2DoubleMap.Entry> iter = v1.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2DoubleMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    resValues[idx] = op.apply(entry.getDoubleValue(), 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]);
                    }
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSorted() && v2.isDense()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntDoubleVectorStorage newStorage = v1.getStorage().emptyDense();
            double[] resValues = newStorage.getValues();
            long[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                int[] v1Indices = v1.getStorage().getIndices();
                double[] 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 {
                IntDoubleVectorStorage 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]);
                    }
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSparse() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntDoubleVectorStorage newStorage = v1.getStorage().emptyDense();
            double[] resValues = newStorage.getValues();
            ObjectIterator<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2DoubleMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                resValues[idx] = entry.getDoubleValue();
            }
            if (v2.size() < Constant.denseLoopThreshold * v2.getDim()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(resValues[i], 0);
                }
                ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    if (v1.getStorage().hasKey(idx)) {
                        resValues[idx] = op.apply(v1.get(idx), entry.getLongValue());
                    }
                }
            } else {
                IntLongVectorStorage v2Storage = v2.getStorage();
                for (int i = 0; i < resValues.length; i++) {
                    if (v2Storage.hasKey(i)) {
                        resValues[i] = op.apply(resValues[i], v2.get(i));
                    } else {
                        resValues[i] = op.apply(resValues[i], 0);
                    }
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntDoubleVectorStorage newStorage = v1.getStorage().emptyDense();
            double[] resValues = newStorage.getValues();
            ObjectIterator<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2DoubleMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                resValues[idx] = entry.getDoubleValue();
            }
            if (v2.size() < Constant.denseLoopThreshold * v2.getDim()) {
                int[] v2Indices = v2.getStorage().getIndices();
                long[] v2Values = v2.getStorage().getValues();
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(resValues[i], 0);
                }
                int size = v2.size();
                for (int i = 0; i < size; i++) {
                    int idx = v2Indices[i];
                    if (v1.getStorage().hasKey(idx)) {
                        resValues[idx] = op.apply(v1.get(idx), v2Values[i]);
                    }
                }
            } else {
                IntLongVectorStorage v2Storage = v2.getStorage();
                for (int i = 0; i < resValues.length; i++) {
                    if (v2Storage.hasKey(i)) {
                        resValues[i] = op.apply(resValues[i], v2.get(i));
                    } else {
                        resValues[i] = op.apply(resValues[i], 0);
                    }
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntDoubleVectorStorage newStorage = v1.getStorage().emptyDense();
            double[] resValues = newStorage.getValues();
            int[] v1Indices = v1.getStorage().getIndices();
            double[] v1Values = v1.getStorage().getValues();
            int size = v1.size();
            for (int i = 0; i < size; i++) {
                int idx = v1Indices[i];
                resValues[idx] = v1Values[i];
            }
            if (v2.size() < Constant.denseLoopThreshold * v2.getDim()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(resValues[i], 0);
                }
                ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    if (v1.getStorage().hasKey(idx)) {
                        resValues[idx] = op.apply(v1.get(idx), entry.getLongValue());
                    }
                }
            } else {
                IntLongVectorStorage v2Storage = v2.getStorage();
                for (int i = 0; i < resValues.length; i++) {
                    if (v2Storage.hasKey(i)) {
                        resValues[i] = op.apply(resValues[i], v2.get(i));
                    } else {
                        resValues[i] = op.apply(resValues[i], 0);
                    }
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            IntDoubleVectorStorage newStorage = v1.getStorage().emptyDense();
            double[] resValues = newStorage.getValues();
            int v1Pointor = 0;
            int v2Pointor = 0;
            int size1 = v1.size();
            int size2 = v2.size();
            int[] v1Indices = v1.getStorage().getIndices();
            double[] v1Values = v1.getStorage().getValues();
            int[] v2Indices = v2.getStorage().getIndices();
            long[] v2Values = v2.getStorage().getValues();
            if (!op.isCompare()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = Double.NaN;
                }
            }
            while (v1Pointor < size1 && v2Pointor < size2) {
                if (v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                    resValues[v1Indices[v1Pointor]] = op.apply(v1Values[v1Pointor], v2Values[v2Pointor]);
                    v1Pointor++;
                    v2Pointor++;
                } else if (v1Indices[v1Pointor] < v2Indices[v2Pointor]) {
                    resValues[v1Indices[v1Pointor]] = op.apply(v1Values[v1Pointor], 0);
                    v1Pointor++;
                } else {
                    // v1Indices[v1Pointor] > v2Indices[v2Pointor]
                    resValues[v2Indices[v2Pointor]] = op.apply(0, v2Values[v2Pointor]);
                    v2Pointor++;
                }
            }
            v1.setStorage(newStorage);
        }
    } else {
        throw new AngelException("The operation is not support!");
    }
    return v1;
}

Example 75 with IntLongVector

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

the class UpdateColsParam method split.

@Override
public List<PartitionUpdateParam> split() {
    List<PartitionKey> pkeys = PSAgentContext.get().getMatrixMetaManager().getPartitions(matrixId);
    List<PartitionUpdateParam> params = new ArrayList<>();
    int start = 0, end = 0;
    for (PartitionKey pkey : pkeys) {
        long startCol = pkey.getStartCol();
        long endCol = pkey.getEndCol();
        if (start < ((IntKeyVector) cols).getDim() && VectorUtils.getLong(cols, start) >= startCol) {
            while (end < ((IntKeyVector) cols).getDim() && VectorUtils.getLong(cols, end) < endCol) end++;
            long[] part = new long[end - start];
            if (cols instanceof IntIntVector) {
                ArrayCopy.copy(((IntIntVector) cols).getStorage().getValues(), start, part, 0, end - start);
            } else {
                System.arraycopy(((IntLongVector) cols).getStorage().getValues(), start, part, 0, end - start);
            }
            long firstKey = 0l;
            for (Map.Entry<Long, Vector> first : values.entrySet()) {
                firstKey = first.getKey();
                break;
            }
            if (values.get(firstKey) instanceof IntDoubleVector) {
                IntDoubleVector[] updates = new IntDoubleVector[part.length];
                for (int i = 0; i < part.length; i++) updates[i] = (IntDoubleVector) values.get(part[i]);
                params.add(new PartitionUpdateColsParam(matrixId, pkey, rows, part, VFactory.compIntDoubleVector(rows.length, updates, part.length), op));
            } else if (values.get(firstKey) instanceof IntFloatVector) {
                IntFloatVector[] updates = new IntFloatVector[part.length];
                for (int i = 0; i < part.length; i++) updates[i] = (IntFloatVector) values.get(part[i]);
                params.add(new PartitionUpdateColsParam(matrixId, pkey, rows, part, VFactory.compIntFloatVector(rows.length, updates, part.length), op));
            } else {
                throw new AngelException("Update data type should be float or double!");
            }
            start = end;
        }
    }
    return params;
}