Search in sources :

Example 56 with LongDoubleVector

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

the class SimpleBinaryOutAllExecutor method apply.

public static Vector apply(LongDoubleVector v1, LongIntVector v2, Binary op) {
    LongDoubleVector res;
    if (v1.isSparse() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            // multi-rehash
            LongDoubleVectorStorage newStorage = v1.getStorage().emptySparse((int) (v1.getDim()));
            LongDoubleVectorStorage 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, 0));
                }
            }
            res = new LongDoubleVector(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 {
            LongDoubleVectorStorage newStorage = v1.getStorage().emptySparse((int) (v1.getDim()));
            LongDoubleVectorStorage 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, 0));
                }
            }
            res = new LongDoubleVector(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 {
            LongDoubleVectorStorage newStorage = new LongDoubleSparseVectorStorage(v1.getDim());
            LongDoubleVectorStorage 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, 0));
                }
            }
            res = new LongDoubleVector(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 {
            LongDoubleVectorStorage newStorage = v1.getStorage().emptySorted((int) (v1.getDim()));
            long[] resIndices = newStorage.getIndices();
            double[] resValues = newStorage.getValues();
            int v1Pointor = 0;
            int v2Pointor = 0;
            long size1 = v1.size();
            long size2 = v2.size();
            long[] v1Indices = v1.getStorage().getIndices();
            double[] v1Values = v1.getStorage().getValues();
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            if (!op.isCompare()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = Double.NaN;
                }
            }
            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 LongDoubleVector(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) LongDoubleVector(com.tencent.angel.ml.math2.vector.LongDoubleVector) LongIntVectorStorage(com.tencent.angel.ml.math2.storage.LongIntVectorStorage) LongDoubleSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSparseVectorStorage) LongDoubleVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage)

Example 57 with LongDoubleVector

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

the class SimpleBinaryInAllExecutor method apply.

public static Vector apply(LongDoubleVector v1, LongIntVector v2, Binary op) {
    if (v1.isSparse() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            // multi-rehash
            LongDoubleVectorStorage newStorage = v1.getStorage().emptySparse((int) (v1.getDim()));
            LongDoubleVectorStorage 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, 0));
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            LongDoubleVectorStorage newStorage = v1.getStorage().emptySparse((int) (v1.getDim()));
            LongDoubleVectorStorage 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, 0));
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            LongDoubleVectorStorage newStorage = new LongDoubleSparseVectorStorage(v1.getDim());
            LongDoubleVectorStorage 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, 0));
                }
            }
            v1.setStorage(newStorage);
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        if (op.isKeepStorage()) {
            throw new AngelException("operation is not support!");
        } else {
            LongDoubleVectorStorage newStorage = v1.getStorage().emptySorted((int) (v1.getDim()));
            long[] resIndices = newStorage.getIndices();
            double[] resValues = newStorage.getValues();
            int v1Pointor = 0;
            int v2Pointor = 0;
            long size1 = v1.size();
            long size2 = v2.size();
            long[] v1Indices = v1.getStorage().getIndices();
            double[] v1Values = v1.getStorage().getValues();
            long[] v2Indices = v2.getStorage().getIndices();
            int[] v2Values = v2.getStorage().getValues();
            if (!op.isCompare()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = Double.NaN;
                }
            }
            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++;
                }
            }
            v1.setStorage(newStorage);
        }
    } else {
        throw new AngelException("The operation is not support!");
    }
    return v1;
}
Also used : AngelException(com.tencent.angel.exception.AngelException) LongIntVectorStorage(com.tencent.angel.ml.math2.storage.LongIntVectorStorage) LongDoubleSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSparseVectorStorage) LongDoubleVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage)

Example 58 with LongDoubleVector

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

the class SimpleBinaryInAllExecutor method apply.

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

Example 59 with LongDoubleVector

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

the class MixedBinaryOutAllExecutor method apply.

private static Vector apply(CompLongDoubleVector v1, LongLongVector v2, Binary op) {
    LongDoubleVector[] 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 LongDoubleSortedVectorStorage) {
                resParts[i] = new LongDoubleSparseVectorStorage(parts[i].getDim(), parts[i].getStorage().getIndices(), parts[i].getStorage().getValues());
            }
        }
    }
    long subDim = (v1.getDim() + v1.getNumPartitions() - 1) / v1.getNumPartitions();
    for (int i = 0; i < v1.getDim(); i++) {
        int pidx = (int) (i / subDim);
        long subidx = i % subDim;
        if (v2.getStorage().hasKey(i)) {
            ((LongDoubleVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), v2.get(i)));
        } else {
            ((LongDoubleVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), 0));
        }
    }
    LongDoubleVector[] res = new LongDoubleVector[parts.length];
    int i = 0;
    for (LongDoubleVector part : parts) {
        res[i] = new LongDoubleVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (LongDoubleVectorStorage) resParts[i]);
        i++;
    }
    return new CompLongDoubleVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), res, v1.getSubDim());
}
Also used : CompLongDoubleVector(com.tencent.angel.ml.math2.vector.CompLongDoubleVector) LongDoubleSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSortedVectorStorage) IntIntVectorStorage(com.tencent.angel.ml.math2.storage.IntIntVectorStorage) Storage(com.tencent.angel.ml.math2.storage.Storage) IntDoubleSparseVectorStorage(com.tencent.angel.ml.math2.storage.IntDoubleSparseVectorStorage) LongIntVectorStorage(com.tencent.angel.ml.math2.storage.LongIntVectorStorage) LongLongSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongLongSparseVectorStorage) IntDoubleSortedVectorStorage(com.tencent.angel.ml.math2.storage.IntDoubleSortedVectorStorage) LongDoubleSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSparseVectorStorage) LongDoubleSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSortedVectorStorage) LongLongVectorStorage(com.tencent.angel.ml.math2.storage.LongLongVectorStorage) LongFloatVectorStorage(com.tencent.angel.ml.math2.storage.LongFloatVectorStorage) IntLongVectorStorage(com.tencent.angel.ml.math2.storage.IntLongVectorStorage) IntIntSortedVectorStorage(com.tencent.angel.ml.math2.storage.IntIntSortedVectorStorage) LongIntSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongIntSortedVectorStorage) IntLongSortedVectorStorage(com.tencent.angel.ml.math2.storage.IntLongSortedVectorStorage) IntLongSparseVectorStorage(com.tencent.angel.ml.math2.storage.IntLongSparseVectorStorage) LongIntSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongIntSparseVectorStorage) IntFloatVectorStorage(com.tencent.angel.ml.math2.storage.IntFloatVectorStorage) IntFloatSortedVectorStorage(com.tencent.angel.ml.math2.storage.IntFloatSortedVectorStorage) LongLongSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongLongSortedVectorStorage) LongDoubleVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage) IntDoubleVectorStorage(com.tencent.angel.ml.math2.storage.IntDoubleVectorStorage) IntIntSparseVectorStorage(com.tencent.angel.ml.math2.storage.IntIntSparseVectorStorage) IntFloatSparseVectorStorage(com.tencent.angel.ml.math2.storage.IntFloatSparseVectorStorage) LongFloatSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongFloatSparseVectorStorage) LongFloatSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongFloatSortedVectorStorage) LongDoubleVector(com.tencent.angel.ml.math2.vector.LongDoubleVector) CompLongDoubleVector(com.tencent.angel.ml.math2.vector.CompLongDoubleVector) LongDoubleSparseVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSparseVectorStorage) LongDoubleVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage)

Example 60 with LongDoubleVector

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

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(LongDoubleVector v1, LongDoubleVector v2, Binary op) {
    LongDoubleVectorStorage newStorage = (LongDoubleVectorStorage) 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<Long2DoubleMap.Entry> iter = v2.getStorage().entryIterator();
            while (iter.hasNext()) {
                Long2DoubleMap.Entry entry = iter.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, op.apply(v1.get(idx), entry.getDoubleValue()));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss dense storage is more efficient
            ObjectIterator<Long2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Long2DoubleMap.Entry entry = iter1.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, entry.getDoubleValue());
            }
            ObjectIterator<Long2DoubleMap.Entry> iter2 = v2.getStorage().entryIterator();
            while (iter2.hasNext()) {
                Long2DoubleMap.Entry entry = iter2.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, op.apply(v1.get(idx), entry.getDoubleValue()));
            }
        } 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<Long2DoubleMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2DoubleMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getDoubleValue()));
                }
            } else {
                // multi-rehash
                ObjectIterator<Long2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Long2DoubleMap.Entry entry = iter1.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, entry.getDoubleValue());
                }
                ObjectIterator<Long2DoubleMap.Entry> iter2 = v2.getStorage().entryIterator();
                while (iter2.hasNext()) {
                    Long2DoubleMap.Entry entry = iter2.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getDoubleValue()));
                }
            }
        }
    } 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();
            double[] 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<Long2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Long2DoubleMap.Entry entry = iter1.next();
                long idx = entry.getLongKey();
                newStorage.set(idx, entry.getDoubleValue());
            }
            long[] v2Indices = v2.getStorage().getIndices();
            double[] 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();
                double[] 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<Long2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Long2DoubleMap.Entry entry = iter1.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, entry.getDoubleValue());
                }
                long[] v2Indices = v2.getStorage().getIndices();
                double[] 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();
                double[] values = new double[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 LongDoubleSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                long[] v1Indices = v1.getStorage().getIndices();
                double[] 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<Long2DoubleMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2DoubleMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getDoubleValue()));
                }
            }
        } 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();
                double[] values = new double[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 LongDoubleSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                long[] v1Indices = v1.getStorage().getIndices();
                double[] 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<Long2DoubleMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Long2DoubleMap.Entry entry = iter.next();
                    long idx = entry.getLongKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getDoubleValue()));
                }
            }
        }
    } 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();
        double[] v1Values = v1.getStorage().getValues();
        long[] v2Indices = v2.getStorage().getIndices();
        double[] v2Values = v2.getStorage().getValues();
        if ((size1 + size2) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                // sorted
                long[] resIndices = newStorage.getIndices();
                double[] 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();
                double[] 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 LongDoubleVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}
Also used : AngelException(com.tencent.angel.exception.AngelException) LongAVLTreeSet(it.unimi.dsi.fastutil.longs.LongAVLTreeSet) LongBidirectionalIterator(it.unimi.dsi.fastutil.longs.LongBidirectionalIterator) Long2DoubleMap(it.unimi.dsi.fastutil.longs.Long2DoubleMap) LongDoubleVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage) ObjectIterator(it.unimi.dsi.fastutil.objects.ObjectIterator) LongDoubleSortedVectorStorage(com.tencent.angel.ml.math2.storage.LongDoubleSortedVectorStorage) LongDoubleVector(com.tencent.angel.ml.math2.vector.LongDoubleVector)

Aggregations

LongDoubleVector (com.tencent.angel.ml.math2.vector.LongDoubleVector)55 LongDoubleVectorStorage (com.tencent.angel.ml.math2.storage.LongDoubleVectorStorage)47 LongDoubleSparseVectorStorage (com.tencent.angel.ml.math2.storage.LongDoubleSparseVectorStorage)37 CompLongDoubleVector (com.tencent.angel.ml.math2.vector.CompLongDoubleVector)34 LongFloatVectorStorage (com.tencent.angel.ml.math2.storage.LongFloatVectorStorage)32 LongIntVectorStorage (com.tencent.angel.ml.math2.storage.LongIntVectorStorage)32 LongLongVectorStorage (com.tencent.angel.ml.math2.storage.LongLongVectorStorage)32 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 LongDoubleSortedVectorStorage (com.tencent.angel.ml.math2.storage.LongDoubleSortedVectorStorage)26 IntDoubleSortedVectorStorage (com.tencent.angel.ml.math2.storage.IntDoubleSortedVectorStorage)20 IntDoubleSparseVectorStorage (com.tencent.angel.ml.math2.storage.IntDoubleSparseVectorStorage)20 IntFloatSortedVectorStorage (com.tencent.angel.ml.math2.storage.IntFloatSortedVectorStorage)20 IntFloatSparseVectorStorage (com.tencent.angel.ml.math2.storage.IntFloatSparseVectorStorage)20 IntIntSortedVectorStorage (com.tencent.angel.ml.math2.storage.IntIntSortedVectorStorage)20 IntIntSparseVectorStorage (com.tencent.angel.ml.math2.storage.IntIntSparseVectorStorage)20 IntLongSortedVectorStorage (com.tencent.angel.ml.math2.storage.IntLongSortedVectorStorage)20