Search in sources :

Example 36 with LongIntVector

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

the class MergeUtils method combineLongIntIndexRowSplits.

// //////////////////////////////////////////////////////////////////////////////
// Combine Long key Int value vector
// //////////////////////////////////////////////////////////////////////////////
public static Vector combineLongIntIndexRowSplits(int matrixId, int rowId, int resultSize, KeyPart[] keyParts, ValuePart[] valueParts, MatrixMeta matrixMeta) {
    LongIntVector vector = VFactory.sparseLongKeyIntVector(matrixMeta.getColNum(), resultSize);
    for (int i = 0; i < keyParts.length; i++) {
        mergeTo(vector, keyParts[i], (IntValuesPart) valueParts[i]);
    }
    vector.setRowId(rowId);
    vector.setMatrixId(matrixId);
    return vector;
}
Also used : LongIntVector(com.tencent.angel.ml.math2.vector.LongIntVector)

Example 37 with LongIntVector

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

the class RBLongIntMatrix method initEmpty.

@Override
public void initEmpty(int idx) {
    if (null == rows[idx]) {
        LongIntSparseVectorStorage storage = new LongIntSparseVectorStorage((long) getDim());
        rows[idx] = new LongIntVector(matrixId, idx, clock, (long) getDim(), storage);
    }
}
Also used : LongIntVector(com.tencent.angel.ml.math2.vector.LongIntVector) LongIntSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongIntSparseVectorStorage)

Example 38 with LongIntVector

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

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(LongIntVector v1, LongIntVector v2, Binary op) {
    LongIntVectorStorage newStorage = (LongIntVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isSparse() && v2.isSparse()) {
        long v1Size = v1.size();
        long 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<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
            while (iter.hasNext()) {
                Long2IntMap.Entry entry = iter.next();
                long idx = entry.getLongKey();
                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<Long2IntMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Long2IntMap.Entry entry = iter1.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, entry.getIntValue());
            }
            ObjectIterator<Long2IntMap.Entry> iter2 = v2.getStorage().entryIterator();
            while (iter2.hasNext()) {
                Long2IntMap.Entry entry = iter2.next();
                long idx = entry.getLongKey();
                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<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2IntMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
                }
            } else {
                // multi-rehash
                ObjectIterator<Long2IntMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Long2IntMap.Entry entry = iter1.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, entry.getIntValue());
                }
                ObjectIterator<Long2IntMap.Entry> iter2 = v2.getStorage().entryIterator();
                while (iter2.hasNext()) {
                    Long2IntMap.Entry entry = iter2.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
                }
            }
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        long v1Size = v1.size();
        long 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
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            for (int i = 0; i < v2.size(); i++) {
                long idx = v2Indices[i];
                newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            ObjectIterator<Long2IntMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Long2IntMap.Entry entry = iter1.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, entry.getIntValue());
            }
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            long size = v2.size();
            for (int i = 0; i < size; i++) {
                long 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) {
                long[] v2Indices = v2.getStorage().getIndices();
                int[] v2Values = v2.getStorage().getValues();
                for (int i = 0; i < v2.size(); i++) {
                    long idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            } else {
                ObjectIterator<Long2IntMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Long2IntMap.Entry entry = iter1.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, entry.getIntValue());
                }
                long[] v2Indices = v2.getStorage().getIndices();
                int[] v2Values = v2.getStorage().getValues();
                long size = v2.size();
                for (int i = 0; i < size; i++) {
                    long idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        long v1Size = v1.size();
        long v2Size = v2.size();
        if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                long[] v1Indices = v1.getStorage().getIndices();
                long[] idxiter = v2.getStorage().indexIterator().toLongArray();
                long[] indices = new long[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                LongAVLTreeSet avl = new LongAVLTreeSet(indices);
                LongBidirectionalIterator iter = avl.iterator();
                int[] values = new int[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    long idx = iter.nextLong();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new LongIntSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                long[] v1Indices = v1.getStorage().getIndices();
                int[] v1Values = v1.getStorage().getValues();
                long size = v1.size();
                for (int i = 0; i < size; i++) {
                    long idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2IntMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getIntValue()));
                }
            }
        } else {
            if (op.isKeepStorage()) {
                long[] v1Indices = v1.getStorage().getIndices();
                long[] idxiter = v2.getStorage().indexIterator().toLongArray();
                long[] indices = new long[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                LongAVLTreeSet avl = new LongAVLTreeSet(indices);
                LongBidirectionalIterator iter = avl.iterator();
                int[] values = new int[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    long idx = iter.nextLong();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new LongIntSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                long[] v1Indices = v1.getStorage().getIndices();
                int[] v1Values = v1.getStorage().getValues();
                long size = v1.size();
                for (int i = 0; i < size; i++) {
                    long idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2IntMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getIntValue()));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        int v1Pointor = 0;
        int v2Pointor = 0;
        long size1 = v1.size();
        long size2 = v2.size();
        long[] v1Indices = v1.getStorage().getIndices();
        int[] v1Values = v1.getStorage().getValues();
        long[] v2Indices = v2.getStorage().getIndices();
        int[] v2Values = v2.getStorage().getValues();
        if ((size1 + size2) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                // sorted
                long[] resIndices = newStorage.getIndices();
                int[] 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()) {
                long[] resIndices = newStorage.getIndices();
                int[] 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 LongIntVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}
Also used : AngelException(com.tencent.angel.exception.AngelException) LongIntVector(com.tencent.angel.ml.math2.vector.LongIntVector) LongIntVectorStorage(com.tencent.angel.ml.math2.storage.LongIntVectorStorage) LongAVLTreeSet(it.unimi.dsi.fastutil.longs.LongAVLTreeSet) LongBidirectionalIterator(it.unimi.dsi.fastutil.longs.LongBidirectionalIterator) Long2IntMap(it.unimi.dsi.fastutil.longs.Long2IntMap) LongIntSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongIntSortedVectorStorage) ObjectIterator(it.unimi.dsi.fastutil.objects.ObjectIterator)

Example 39 with LongIntVector

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

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(LongFloatVector v1, LongIntVector v2, Binary op) {
    LongFloatVectorStorage newStorage = (LongFloatVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isSparse() && v2.isSparse()) {
        long v1Size = v1.size();
        long 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<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
            while (iter.hasNext()) {
                Long2IntMap.Entry entry = iter.next();
                long idx = entry.getLongKey();
                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<Long2FloatMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Long2FloatMap.Entry entry = iter1.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, entry.getFloatValue());
            }
            ObjectIterator<Long2IntMap.Entry> iter2 = v2.getStorage().entryIterator();
            while (iter2.hasNext()) {
                Long2IntMap.Entry entry = iter2.next();
                long idx = entry.getLongKey();
                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<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2IntMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
                }
            } else {
                // multi-rehash
                ObjectIterator<Long2FloatMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Long2FloatMap.Entry entry = iter1.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, entry.getFloatValue());
                }
                ObjectIterator<Long2IntMap.Entry> iter2 = v2.getStorage().entryIterator();
                while (iter2.hasNext()) {
                    Long2IntMap.Entry entry = iter2.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getIntValue()));
                }
            }
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        long v1Size = v1.size();
        long 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
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            for (int i = 0; i < v2.size(); i++) {
                long idx = v2Indices[i];
                newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            ObjectIterator<Long2FloatMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Long2FloatMap.Entry entry = iter1.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, entry.getFloatValue());
            }
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            long size = v2.size();
            for (int i = 0; i < size; i++) {
                long 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) {
                long[] v2Indices = v2.getStorage().getIndices();
                int[] v2Values = v2.getStorage().getValues();
                for (int i = 0; i < v2.size(); i++) {
                    long idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            } else {
                ObjectIterator<Long2FloatMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Long2FloatMap.Entry entry = iter1.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, entry.getFloatValue());
                }
                long[] v2Indices = v2.getStorage().getIndices();
                int[] v2Values = v2.getStorage().getValues();
                long size = v2.size();
                for (int i = 0; i < size; i++) {
                    long idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        long v1Size = v1.size();
        long v2Size = v2.size();
        if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                long[] v1Indices = v1.getStorage().getIndices();
                long[] idxiter = v2.getStorage().indexIterator().toLongArray();
                long[] indices = new long[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                LongAVLTreeSet avl = new LongAVLTreeSet(indices);
                LongBidirectionalIterator iter = avl.iterator();
                float[] values = new float[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    long idx = iter.nextLong();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new LongFloatSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                long[] v1Indices = v1.getStorage().getIndices();
                float[] v1Values = v1.getStorage().getValues();
                long size = v1.size();
                for (int i = 0; i < size; i++) {
                    long idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2IntMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getIntValue()));
                }
            }
        } else {
            if (op.isKeepStorage()) {
                long[] v1Indices = v1.getStorage().getIndices();
                long[] idxiter = v2.getStorage().indexIterator().toLongArray();
                long[] indices = new long[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                LongAVLTreeSet avl = new LongAVLTreeSet(indices);
                LongBidirectionalIterator iter = avl.iterator();
                float[] values = new float[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    long idx = iter.nextLong();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new LongFloatSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                long[] v1Indices = v1.getStorage().getIndices();
                float[] v1Values = v1.getStorage().getValues();
                long size = v1.size();
                for (int i = 0; i < size; i++) {
                    long idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Long2IntMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2IntMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getIntValue()));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        int v1Pointor = 0;
        int v2Pointor = 0;
        long size1 = v1.size();
        long size2 = v2.size();
        long[] v1Indices = v1.getStorage().getIndices();
        float[] v1Values = v1.getStorage().getValues();
        long[] v2Indices = v2.getStorage().getIndices();
        int[] v2Values = v2.getStorage().getValues();
        if ((size1 + size2) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                // sorted
                long[] resIndices = newStorage.getIndices();
                float[] 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()) {
                long[] resIndices = newStorage.getIndices();
                float[] 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 LongFloatVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}
Also used : AngelException(com.tencent.angel.exception.AngelException) LongFloatVectorStorage(com.tencent.angel.ml.math2.storage.LongFloatVectorStorage) LongAVLTreeSet(it.unimi.dsi.fastutil.longs.LongAVLTreeSet) LongBidirectionalIterator(it.unimi.dsi.fastutil.longs.LongBidirectionalIterator) Long2IntMap(it.unimi.dsi.fastutil.longs.Long2IntMap) LongFloatVector(com.tencent.angel.ml.math2.vector.LongFloatVector) ObjectIterator(it.unimi.dsi.fastutil.objects.ObjectIterator) Long2FloatMap(it.unimi.dsi.fastutil.longs.Long2FloatMap) LongFloatSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongFloatSortedVectorStorage)

Example 40 with LongIntVector

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

the class SimpleBinaryOutAllExecutor method apply.

public static Vector apply(LongLongVector v1, LongIntVector v2, Binary op) {
    LongLongVector res;
    if (v1.isSparse() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            // multi-rehash
            LongLongVectorStorage newStorage = v1.getStorage().emptySparse((int) (v1.getDim()));
            LongLongVectorStorage v1Storage = v1.getStorage();
            LongIntVectorStorage v2Storage = v2.getStorage();
            for (int i = 0; i < v1.getDim(); i++) {
                if (v1Storage.hasKey(i) && v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(v1.get(i), v2.get(i)));
                } else if (v1Storage.hasKey(i) && !v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(v1.get(i), 0));
                } else if (!v1Storage.hasKey(i) && v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(0, v2.get(i)));
                } else {
                    newStorage.set(i, op.apply(0, 0));
                }
            }
            res = new LongLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            LongLongVectorStorage newStorage = v1.getStorage().emptySparse((int) (v1.getDim()));
            LongLongVectorStorage v1Storage = v1.getStorage();
            LongIntVectorStorage v2Storage = v2.getStorage();
            for (int i = 0; i < v1.getDim(); i++) {
                if (v1Storage.hasKey(i) && v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(v1.get(i), v2.get(i)));
                } else if (v1Storage.hasKey(i) && !v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(v1.get(i), 0));
                } else if (!v1Storage.hasKey(i) && v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(0, v2.get(i)));
                } else {
                    newStorage.set(i, op.apply(0, 0));
                }
            }
            res = new LongLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            LongLongVectorStorage newStorage = new LongLongSparseVectorStorage(v1.getDim());
            LongLongVectorStorage v1Storage = v1.getStorage();
            LongIntVectorStorage v2Storage = v2.getStorage();
            for (int i = 0; i < v1.getDim(); i++) {
                if (v1Storage.hasKey(i) && v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(v1.get(i), v2.get(i)));
                } else if (v1Storage.hasKey(i) && !v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(v1.get(i), 0));
                } else if (!v1Storage.hasKey(i) && v2Storage.hasKey(i)) {
                    newStorage.set(i, op.apply(0, v2.get(i)));
                } else {
                    newStorage.set(i, op.apply(0, 0));
                }
            }
            res = new LongLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            LongLongVectorStorage newStorage = v1.getStorage().emptySorted((int) (v1.getDim()));
            long[] resIndices = newStorage.getIndices();
            long[] resValues = newStorage.getValues();
            int v1Pointor = 0;
            int v2Pointor = 0;
            long size1 = v1.size();
            long size2 = v2.size();
            long[] v1Indices = v1.getStorage().getIndices();
            long[] v1Values = v1.getStorage().getValues();
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            if (!op.isCompare()) {
                if (size1 != v1.getDim() && size2 != v2.getDim()) {
                    for (int i = 0; i < v1.getDim(); i++) {
                        resValues[i] = 0 / 0;
                    }
                }
            }
            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] = op.apply(v2Values[v2Pointor], 0);
                    v1Pointor++;
                    globalPointor++;
                } else {
                    // v1Indices[v1Pointor] > v2Indices[v2Pointor]
                    resIndices[globalPointor] = v2Indices[v2Pointor];
                    resValues[globalPointor] = op.apply(0, v2Values[v2Pointor]);
                    v2Pointor++;
                    globalPointor++;
                }
            }
            res = new LongLongVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
        }
    } else {
        throw new AngelException("The operation is not support!");
    }
    return res;
}
Also used : AngelException(com.tencent.angel.exception.AngelException) LongIntVectorStorage(com.tencent.angel.ml.math2.storage.LongIntVectorStorage) LongLongVector(com.tencent.angel.ml.math2.vector.LongLongVector) LongLongVectorStorage(com.tencent.angel.ml.math2.storage.LongLongVectorStorage) LongLongSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongLongSparseVectorStorage)

Aggregations

LongIntVectorStorage (com.tencent.angel.ml.math2.storage.LongIntVectorStorage)48 LongDoubleVectorStorage (com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage)33 LongFloatVectorStorage (com.tencent.angel.ml.math2.storage.LongFloatVectorStorage)33 LongLongVectorStorage (com.tencent.angel.ml.math2.storage.LongLongVectorStorage)33 LongIntVector (com.tencent.angel.ml.math2.vector.LongIntVector)32 LongIntSparseVectorStorage (com.tencent.angel.ml.math2.storage.LongIntSparseVectorStorage)31 IntDoubleVectorStorage (com.tencent.angel.ml.math2.storage.IntDoubleVectorStorage)30 IntFloatVectorStorage (com.tencent.angel.ml.math2.storage.IntFloatVectorStorage)30 IntIntVectorStorage (com.tencent.angel.ml.math2.storage.IntIntVectorStorage)30 IntLongVectorStorage (com.tencent.angel.ml.math2.storage.IntLongVectorStorage)30 Storage (com.tencent.angel.ml.math2.storage.Storage)30 Long2IntMap (it.unimi.dsi.fastutil.longs.Long2IntMap)27 LongIntSortedVectorStorage (com.tencent.angel.ml.math2.storage.LongIntSortedVectorStorage)23 LongDoubleSparseVectorStorage (com.tencent.angel.ml.math2.storage.LongDoubleSparseVectorStorage)22 LongFloatSparseVectorStorage (com.tencent.angel.ml.math2.storage.LongFloatSparseVectorStorage)22 LongLongSparseVectorStorage (com.tencent.angel.ml.math2.storage.LongLongSparseVectorStorage)22 LongDoubleSortedVectorStorage (com.tencent.angel.ml.math2.storage.LongDoubleSortedVectorStorage)21 LongFloatSortedVectorStorage (com.tencent.angel.ml.math2.storage.LongFloatSortedVectorStorage)21 LongLongSortedVectorStorage (com.tencent.angel.ml.math2.storage.LongLongSortedVectorStorage)21 IntDoubleSortedVectorStorage (com.tencent.angel.ml.math2.storage.IntDoubleSortedVectorStorage)20