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

Example 11 with IntFloatVector

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

the class BinaryMatrixExecutor method apply.

private static Matrix apply(BlasDoubleMatrix mat, IntFloatVector v, boolean onCol, Binary op) {
    double[] data = mat.getData();
    int m = mat.getNumRows(), n = mat.getNumCols();
    int size = v.size();
    byte[] flag = null;
    if (!v.isDense()) {
        flag = new byte[v.getDim()];
    }
    if (onCol && op.isInplace()) {
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int i = 0; i < m; i++) {
                float value = values[i];
                for (int j = 0; j < n; j++) {
                    data[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int i = entry.getIntKey();
                flag[i] = 1;
                double value = entry.getFloatValue();
                for (int j = 0; j < n; j++) {
                    data[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int i = idxs[k];
                flag[i] = 1;
                float value = values[k];
                for (int j = 0; j < n; j++) {
                    data[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    for (int i = 0; i < m; i++) {
                        if (flag[i] == 0) {
                            for (int j = 0; j < n; j++) {
                                data[i * n + j] = 0;
                            }
                        }
                    }
                case UNION:
                    break;
                case ALL:
                    for (int i = 0; i < m; i++) {
                        if (flag[i] == 0) {
                            for (int j = 0; j < n; j++) {
                                data[i * n + j] = op.apply(data[i * n + j], 0);
                            }
                        }
                    }
            }
        }
        return mat;
    } else if (onCol && !op.isInplace()) {
        double[] newData;
        if (op.getOpType() == INTERSECTION) {
            newData = new double[m * n];
        } else {
            newData = ArrayCopy.copy(data);
        }
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int i = 0; i < m; i++) {
                float value = values[i];
                for (int j = 0; j < n; j++) {
                    newData[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int i = entry.getIntKey();
                flag[i] = 1;
                double value = entry.getFloatValue();
                for (int j = 0; j < n; j++) {
                    newData[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int i = idxs[k];
                flag[i] = 1;
                float value = values[k];
                for (int j = 0; j < n; j++) {
                    newData[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    break;
                case UNION:
                    break;
                case ALL:
                    for (int i = 0; i < m; i++) {
                        if (flag[i] == 0) {
                            for (int j = 0; j < n; j++) {
                                newData[i * n + j] = op.apply(data[i * n + j], 0);
                            }
                        }
                    }
            }
        }
        return new BlasDoubleMatrix(mat.getMatrixId(), mat.getClock(), m, n, newData);
    } else if (!onCol && op.isInplace()) {
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    data[i * n + j] = op.apply(data[i * n + j], values[j]);
                }
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int j = entry.getIntKey();
                double value = entry.getFloatValue();
                flag[j] = 1;
                for (int i = 0; i < m; i++) {
                    data[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int j = idxs[k];
                float value = values[k];
                flag[j] = 1;
                for (int i = 0; i < m; i++) {
                    data[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    for (int j = 0; j < n; j++) {
                        if (flag[j] == 0) {
                            for (int i = 0; i < m; i++) {
                                data[i * n + j] = 0;
                            }
                        }
                    }
                case UNION:
                    break;
                case ALL:
                    for (int j = 0; j < n; j++) {
                        if (flag[j] == 0) {
                            for (int i = 0; i < m; i++) {
                                data[i * n + j] = op.apply(data[i * n + j], 0);
                            }
                        }
                    }
            }
        }
        return mat;
    } else {
        double[] newData;
        if (op.getOpType() == INTERSECTION) {
            newData = new double[m * n];
        } else {
            newData = ArrayCopy.copy(data);
        }
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int j = 0; j < n; j++) {
                float value = values[j];
                for (int i = 0; i < m; i++) {
                    newData[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int j = entry.getIntKey();
                flag[j] = 1;
                double value = entry.getFloatValue();
                for (int i = 0; i < m; i++) {
                    newData[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int j = idxs[k];
                flag[j] = 1;
                float value = values[k];
                for (int i = 0; i < m; i++) {
                    newData[i * n + j] = op.apply(data[i * n + j], value);
                }
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    break;
                case UNION:
                    break;
                case ALL:
                    for (int j = 0; j < n; j++) {
                        if (flag[j] == 0) {
                            for (int i = 0; i < m; i++) {
                                newData[i * n + j] = op.apply(data[i * n + j], 0);
                            }
                        }
                    }
            }
        }
        return new BlasDoubleMatrix(mat.getMatrixId(), mat.getClock(), m, n, newData);
    }
}

Example 12 with IntFloatVector

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

the class MixedBinaryInAllExecutor method apply.

private static Vector apply(CompIntFloatVector v1, IntIntVector v2, Binary op) {
    IntFloatVector[] parts = v1.getPartitions();
    Storage[] resParts = StorageSwitch.applyComp(v1, v2, op);
    if (v2.isDense()) {
        int[] v2Values = v2.getStorage().getValues();
        int base = 0, k = 0;
        for (IntFloatVector part : parts) {
            IntFloatVectorStorage resPart = (IntFloatVectorStorage) resParts[k];
            if (part.isDense()) {
                float[] partValue = part.getStorage().getValues();
                float[] resPartValues = resPart.getValues();
                for (int i = 0; i < partValue.length; i++) {
                    int idx = i + base;
                    resPartValues[i] = op.apply(partValue[i], v2Values[idx]);
                }
            } else if (part.isSparse()) {
                float[] resPartValues = resPart.getValues();
                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<Int2FloatMap.Entry> iter = part.getStorage().entryIterator();
                    while (iter.hasNext()) {
                        Int2FloatMap.Entry entry = iter.next();
                        int idx = entry.getIntKey();
                        resPart.set(idx, op.apply(entry.getFloatValue(), v2Values[idx + base]));
                    }
                } else {
                    for (int i = 0; i < resPartValues.length; 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
                int[] resPartIndices = resPart.getIndices();
                float[] resPartValues = resPart.getValues();
                if (op.isKeepStorage()) {
                    if (part.size() < Constant.denseLoopThreshold * part.getDim()) {
                        int[] partIndices = part.getStorage().getIndices();
                        float[] 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 {
                        IntFloatVectorStorage 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 {
                    if (part.size() < Constant.denseLoopThreshold * part.getDim()) {
                        int[] partIndices = part.getStorage().getIndices();
                        float[] 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 {
                        IntFloatVectorStorage 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 IntFloatSortedVectorStorage) {
                    resParts[i] = new IntFloatSparseVectorStorage(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)) {
                ((IntFloatVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), v2.get(i)));
            } else {
                ((IntFloatVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), 0));
            }
        }
    }
    IntFloatVector[] res = new IntFloatVector[parts.length];
    int i = 0;
    for (IntFloatVector part : parts) {
        res[i] = new IntFloatVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntFloatVectorStorage) resParts[i]);
        i++;
    }
    v1.setPartitions(res);
    return v1;
}

Example 13 with IntFloatVector

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

the class MixedBinaryInAllExecutor method apply.

private static Vector apply(CompIntFloatVector v1, IntDummyVector v2, Binary op) {
    IntFloatVector[] 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 IntFloatSortedVectorStorage) {
                resParts[i] = new IntFloatSparseVectorStorage(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;
        ((IntFloatVectorStorage) resParts[pidx]).set(subidx, op.apply(parts[pidx].get(subidx), v2.get(i)));
    }
    IntFloatVector[] res = new IntFloatVector[parts.length];
    int i = 0;
    for (IntFloatVector part : parts) {
        res[i] = new IntFloatVector(part.getMatrixId(), part.getRowId(), part.getClock(), part.getDim(), (IntFloatVectorStorage) resParts[i]);
        i++;
    }
    v1.setPartitions(res);
    return v1;
}

Example 14 with IntFloatVector

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

the class CompReduceExecutor method apply.

private static UnionEle apply(CompIntFloatVector v, ReduceOP op, int start, int end) {
    UnionEle res = new UnionEle();
    IntFloatVector[] parts = v.getPartitions();
    switch(op) {
        case Sum:
            for (int i = start; i <= end; i++) {
                res.setDouble1(res.getDouble1() + parts[i].sum());
            }
            break;
        case Avg:
            for (int i = start; i <= end; i++) {
                res.setDouble1(res.getDouble1() + parts[i].sum());
                res.setLong1(res.getLong1() + parts[i].getDim());
            }
            break;
        case Std:
            for (int i = start; i <= end; i++) {
                res.setDouble1(res.getDouble1() + parts[i].sum());
                double norm = parts[i].norm();
                res.setDouble2(res.getDouble2() + norm * norm);
                res.setLong1(res.getLong1() + parts[i].getDim());
            }
            break;
        case Norm:
            for (int i = start; i <= end; i++) {
                double norm = parts[i].norm();
                res.setDouble2(res.getDouble2() + norm * norm);
            }
            break;
        case Min:
            res.setDouble1(Double.MAX_VALUE);
            for (int i = start; i <= end; i++) {
                res.setDouble1(Math.min(res.getDouble1(), parts[i].min()));
            }
            break;
        case Max:
            res.setDouble1(Double.MIN_VALUE);
            for (int i = start; i <= end; i++) {
                res.setDouble1(Math.max(res.getDouble1(), parts[i].max()));
            }
            break;
        case Size:
            for (int i = start; i <= end; i++) {
                res.setLong1(res.getLong1() + parts[i].size());
            }
            break;
        case Numzeros:
            for (int i = start; i <= end; i++) {
                res.setLong1(res.getLong1() + parts[i].numZeros());
            }
            break;
    }
    return res;
}

Example 15 with IntFloatVector

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

the class BinaryMatrixExecutor method apply.

private static Matrix apply(BlasDoubleMatrix mat, IntFloatVector v, int idx, boolean onCol, Binary op) {
    double[] data = mat.getData();
    int m = mat.getNumRows(), n = mat.getNumCols();
    int size = v.size();
    byte[] flag = null;
    if (!v.isDense()) {
        flag = new byte[v.getDim()];
    }
    if (onCol && op.isInplace()) {
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int i = 0; i < m; i++) {
                data[i * n + idx] = op.apply(data[i * n + idx], values[i]);
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int i = entry.getIntKey();
                flag[i] = 1;
                data[i * n + idx] = op.apply(data[i * n + idx], entry.getFloatValue());
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int i = idxs[k];
                flag[i] = 1;
                data[i * n + idx] = op.apply(data[i * n + idx], values[k]);
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    for (int i = 0; i < m; i++) {
                        if (flag[i] == 0) {
                            data[i * n + idx] = 0;
                        }
                    }
                case UNION:
                    break;
                case ALL:
                    for (int i = 0; i < m; i++) {
                        if (flag[i] == 0) {
                            data[i * n + idx] = op.apply(data[i * n + idx], 0);
                        }
                    }
            }
        }
        return mat;
    } else if (onCol && !op.isInplace()) {
        double[] newData;
        if (op.getOpType() == INTERSECTION) {
            newData = new double[m * n];
        } else {
            newData = ArrayCopy.copy(data);
        }
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int i = 0; i < m; i++) {
                newData[i * n + idx] = op.apply(data[i * n + idx], values[i]);
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int i = entry.getIntKey();
                flag[i] = 1;
                newData[i * n + idx] = op.apply(data[i * n + idx], entry.getFloatValue());
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int i = idxs[k];
                flag[i] = 1;
                newData[i * n + idx] = op.apply(data[i * n + idx], values[k]);
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    break;
                case UNION:
                    break;
                case ALL:
                    for (int i = 0; i < m; i++) {
                        if (flag[i] == 0) {
                            newData[i * n + idx] = op.apply(data[i * n + idx], 0);
                        }
                    }
            }
        }
        return new BlasDoubleMatrix(mat.getMatrixId(), mat.getClock(), m, n, newData);
    } else if (!onCol && op.isInplace()) {
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int j = 0; j < n; j++) {
                data[idx * n + j] = op.apply(data[idx * n + j], values[j]);
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int j = entry.getIntKey();
                flag[j] = 1;
                data[idx * n + j] = op.apply(data[idx * n + j], entry.getFloatValue());
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int j = idxs[k];
                flag[j] = 1;
                data[idx * n + j] = op.apply(data[idx * n + j], values[k]);
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    for (int j = 0; j < n; j++) {
                        if (flag[j] == 0) {
                            data[idx * n + j] = 0;
                        }
                    }
                case UNION:
                    break;
                case ALL:
                    for (int j = 0; j < n; j++) {
                        if (flag[j] == 0) {
                            data[idx * n + j] = op.apply(data[idx * n + j], 0);
                        }
                    }
            }
        }
        return mat;
    } else {
        double[] newData;
        if (op.getOpType() == INTERSECTION) {
            newData = new double[m * n];
        } else {
            newData = ArrayCopy.copy(data);
        }
        if (v.isDense()) {
            float[] values = v.getStorage().getValues();
            for (int j = 0; j < n; j++) {
                newData[idx * n + j] = op.apply(data[idx * n + j], values[j]);
            }
        } else if (v.isSparse()) {
            ObjectIterator<Int2FloatMap.Entry> iter = v.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2FloatMap.Entry entry = iter.next();
                int j = entry.getIntKey();
                flag[j] = 1;
                newData[idx * n + j] = op.apply(data[idx * n + j], entry.getFloatValue());
            }
        } else {
            // sorted
            int[] idxs = v.getStorage().getIndices();
            float[] values = v.getStorage().getValues();
            for (int k = 0; k < size; k++) {
                int j = idxs[k];
                flag[j] = 1;
                newData[idx * n + j] = op.apply(data[idx * n + j], values[k]);
            }
        }
        if (!v.isDense()) {
            switch(op.getOpType()) {
                case INTERSECTION:
                    break;
                case UNION:
                    break;
                case ALL:
                    for (int j = 0; j < n; j++) {
                        if (flag[j] == 0) {
                            newData[idx * n + j] = op.apply(data[idx * n + j], 0);
                        }
                    }
            }
        }
        return new BlasDoubleMatrix(mat.getMatrixId(), mat.getClock(), m, n, newData);
    }
}