ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From agoncha...@apache.org
Subject [10/62] [abbrv] ignite git commit: IGNITE-5000 Rename Ignite Math module to Ignite ML module
Date Tue, 18 Apr 2017 13:45:55 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java
new file mode 100644
index 0000000..82c90ec
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java
@@ -0,0 +1,366 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.decompositions;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.apache.ignite.math.exceptions.SingularMatrixException;
+
+/**
+ * Calculates the LU-decomposition of a square matrix.
+ *
+ * This class inspired by class from Apache Common Math with similar name.
+ *
+ * @see <a href="http://mathworld.wolfram.com/LUDecomposition.html">MathWorld</a>
+ * @see <a href="http://en.wikipedia.org/wiki/LU_decomposition">Wikipedia</a>
+ */
+public class LUDecomposition extends DecompositionSupport {
+    /** Default bound to determine effective singularity in LU decomposition. */
+    private static final double DEFAULT_TOO_SMALL = 1e-11;
+
+    /** Pivot permutation associated with LU decomposition. */
+    private final Vector pivot;
+    /** Parity of the permutation associated with the LU decomposition. */
+    private boolean even;
+    /** Singularity indicator. */
+    private boolean singular;
+    /** Cached value of L. */
+    private Matrix cachedL;
+    /** Cached value of U. */
+    private Matrix cachedU;
+    /** Cached value of P. */
+    private Matrix cachedP;
+    /** Original matrix. */
+    private Matrix matrix;
+    /** Entries of LU decomposition. */
+    private Matrix lu;
+
+    /**
+     * Calculates the LU-decomposition of the given matrix.
+     * This constructor uses 1e-11 as default value for the singularity
+     * threshold.
+     *
+     * @param matrix Matrix to decompose.
+     * @throws CardinalityException if matrix is not square.
+     */
+    public LUDecomposition(Matrix matrix) {
+        this(matrix, DEFAULT_TOO_SMALL);
+    }
+
+    /**
+     * Calculates the LUP-decomposition of the given matrix.
+     *
+     * @param matrix Matrix to decompose.
+     * @param singularityThreshold threshold (based on partial row norm).
+     * @throws CardinalityException if matrix is not square.
+     */
+    public LUDecomposition(Matrix matrix, double singularityThreshold) {
+        assert matrix != null;
+
+        int rows = matrix.rowSize();
+        int cols = matrix.columnSize();
+
+        if (rows != cols)
+            throw new CardinalityException(rows, cols);
+
+        this.matrix = matrix;
+
+        lu = copy(matrix);
+
+        pivot = likeVector(matrix);
+
+        for (int i = 0; i < pivot.size(); i++)
+            pivot.setX(i, i);
+
+        even = true;
+        singular = false;
+
+        cachedL = null;
+        cachedU = null;
+        cachedP = null;
+
+        for (int col = 0; col < cols; col++) {
+
+            //upper
+            for (int row = 0; row < col; row++) {
+                Vector luRow = lu.viewRow(row);
+                double sum = luRow.get(col);
+
+                for (int i = 0; i < row; i++)
+                    sum -= luRow.getX(i) * lu.getX(i, col);
+
+                luRow.setX(col, sum);
+            }
+
+            // permutation row
+            int max = col;
+
+            double largest = Double.NEGATIVE_INFINITY;
+
+            // lower
+            for (int row = col; row < rows; row++) {
+                Vector luRow = lu.viewRow(row);
+                double sum = luRow.getX(col);
+
+                for (int i = 0; i < col; i++)
+                    sum -= luRow.getX(i) * lu.getX(i, col);
+
+                luRow.setX(col, sum);
+
+                if (Math.abs(sum) > largest) {
+                    largest = Math.abs(sum);
+                    max = row;
+                }
+            }
+
+            // Singularity check
+            if (Math.abs(lu.getX(max, col)) < singularityThreshold) {
+                singular = true;
+                return;
+            }
+
+            // Pivot if necessary
+            if (max != col) {
+                double tmp;
+                Vector luMax = lu.viewRow(max);
+                Vector luCol = lu.viewRow(col);
+
+                for (int i = 0; i < cols; i++) {
+                    tmp = luMax.getX(i);
+                    luMax.setX(i, luCol.getX(i));
+                    luCol.setX(i, tmp);
+                }
+
+                int temp = (int)pivot.getX(max);
+                pivot.setX(max, pivot.getX(col));
+                pivot.setX(col, temp);
+
+                even = !even;
+            }
+
+            // Divide the lower elements by the "winning" diagonal elt.
+            final double luDiag = lu.getX(col, col);
+
+            for (int row = col + 1; row < cols; row++) {
+                double val = lu.getX(row, col) / luDiag;
+                lu.setX(row, col, val);
+            }
+        }
+    }
+
+    /**
+     * Destroys decomposition components and other internal components of decomposition.
+     */
+    @Override public void destroy() {
+        if (cachedL != null)
+            cachedL.destroy();
+        if (cachedU != null)
+            cachedU.destroy();
+        if (cachedP != null)
+            cachedP.destroy();
+        lu.destroy();
+    }
+
+    /**
+     * Returns the matrix L of the decomposition.
+     * <p>L is a lower-triangular matrix</p>
+     *
+     * @return the L matrix (or null if decomposed matrix is singular).
+     */
+    public Matrix getL() {
+        if ((cachedL == null) && !singular) {
+            final int m = pivot.size();
+
+            cachedL = like(matrix);
+            cachedL.assign(0.0);
+
+            for (int i = 0; i < m; ++i) {
+                for (int j = 0; j < i; ++j)
+                    cachedL.setX(i, j, lu.getX(i, j));
+
+                cachedL.setX(i, i, 1.0);
+            }
+        }
+
+        return cachedL;
+    }
+
+    /**
+     * Returns the matrix U of the decomposition.
+     * <p>U is an upper-triangular matrix</p>
+     *
+     * @return the U matrix (or null if decomposed matrix is singular).
+     */
+    public Matrix getU() {
+        if ((cachedU == null) && !singular) {
+            final int m = pivot.size();
+
+            cachedU = like(matrix);
+            cachedU.assign(0.0);
+
+            for (int i = 0; i < m; ++i)
+                for (int j = i; j < m; ++j)
+                    cachedU.setX(i, j, lu.getX(i, j));
+        }
+
+        return cachedU;
+    }
+
+    /**
+     * Returns the P rows permutation matrix.
+     * <p>P is a sparse matrix with exactly one element set to 1.0 in
+     * each row and each column, all other elements being set to 0.0.</p>
+     * <p>The positions of the 1 elements are given by the {@link #getPivot()
+     * pivot permutation vector}.</p>
+     *
+     * @return the P rows permutation matrix (or null if decomposed matrix is singular).
+     * @see #getPivot()
+     */
+    public Matrix getP() {
+        if ((cachedP == null) && !singular) {
+            final int m = pivot.size();
+
+            cachedP = like(matrix);
+            cachedP.assign(0.0);
+
+            for (int i = 0; i < m; ++i)
+                cachedP.setX(i, (int)pivot.get(i), 1.0);
+        }
+
+        return cachedP;
+    }
+
+    /**
+     * Returns the pivot permutation vector.
+     *
+     * @return the pivot permutation vector.
+     * @see #getP()
+     */
+    public Vector getPivot() {
+        return pivot.copy();
+    }
+
+    /**
+     * Return the determinant of the matrix.
+     *
+     * @return determinant of the matrix.
+     */
+    public double determinant() {
+        if (singular)
+            return 0;
+
+        final int m = pivot.size();
+        double determinant = even ? 1 : -1;
+
+        for (int i = 0; i < m; i++)
+            determinant *= lu.getX(i, i);
+
+        return determinant;
+    }
+
+    /** */
+    public Vector solve(Vector b) {
+        final int m = pivot.size();
+
+        if (b.size() != m)
+            throw new CardinalityException(b.size(), m);
+
+        if (singular)
+            throw new SingularMatrixException();
+
+        final double[] bp = new double[m];
+
+        // Apply permutations to b
+        for (int row = 0; row < m; row++)
+            bp[row] = b.get((int)pivot.get(row));
+
+        // Solve LY = b
+        for (int col = 0; col < m; col++) {
+            final double bpCol = bp[col];
+
+            for (int i = col + 1; i < m; i++)
+                bp[i] -= bpCol * lu.get(i, col);
+        }
+
+        // Solve UX = Y
+        for (int col = m - 1; col >= 0; col--) {
+            bp[col] /= lu.get(col, col);
+            final double bpCol = bp[col];
+
+            for (int i = 0; i < col; i++)
+                bp[i] -= bpCol * lu.get(i, col);
+        }
+
+        return b.like(m).assign(bp);
+    }
+
+    /** */
+    public Matrix solve(Matrix b) {
+        final int m = pivot.size();
+
+        if (b.rowSize() != m)
+            throw new CardinalityException(b.rowSize(), m);
+
+        if (singular)
+            throw new SingularMatrixException();
+
+        final int nColB = b.columnSize();
+
+        // Apply permutations to b
+        final double[][] bp = new double[m][nColB];
+        for (int row = 0; row < m; row++) {
+            final double[] bpRow = bp[row];
+            final int pRow = (int)pivot.get(row);
+
+            for (int col = 0; col < nColB; col++)
+                bpRow[col] = b.get(pRow, col);
+        }
+
+        // Solve LY = b
+        for (int col = 0; col < m; col++) {
+            final double[] bpCol = bp[col];
+            for (int i = col + 1; i < m; i++) {
+                final double[] bpI = bp[i];
+                final double luICol = lu.get(i, col);
+
+                for (int j = 0; j < nColB; j++)
+                    bpI[j] -= bpCol[j] * luICol;
+            }
+        }
+
+        // Solve UX = Y
+        for (int col = m - 1; col >= 0; col--) {
+            final double[] bpCol = bp[col];
+            final double luDiag = lu.getX(col, col);
+
+            for (int j = 0; j < nColB; j++)
+                bpCol[j] /= luDiag;
+
+            for (int i = 0; i < col; i++) {
+                final double[] bpI = bp[i];
+                final double luICol = lu.get(i, col);
+
+                for (int j = 0; j < nColB; j++)
+                    bpI[j] -= bpCol[j] * luICol;
+            }
+        }
+
+        return b.like(b.rowSize(), b.columnSize()).assign(bp);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java
new file mode 100644
index 0000000..9608ed5
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java
@@ -0,0 +1,186 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.decompositions;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.functions.Functions;
+
+/**
+ * For an {@code m x n} matrix {@code A} with {@code m >= n}, the QR decomposition
+ * is an {@code m x n} orthogonal matrix {@code Q} and an {@code n x n} upper
+ * triangular matrix {@code R} so that {@code A = Q*R}.
+ */
+public class QRDecomposition extends DecompositionSupport {
+    /** */
+    private final Matrix q;
+    /** */
+    private final Matrix r;
+
+    /** */
+    private final Matrix mType;
+    /** */
+    private final boolean fullRank;
+
+    /** */
+    private final int rows;
+    /** */
+    private final int cols;
+
+    /**
+     * @param v Value to be checked for being an ordinary double.
+     */
+    private void checkDouble(double v) {
+        if (Double.isInfinite(v) || Double.isNaN(v))
+            throw new ArithmeticException("Invalid intermediate result");
+    }
+
+    /**
+     * Constructs a new QR decomposition object computed by Householder reflections.
+     *
+     * @param mtx A rectangular matrix.
+     */
+    public QRDecomposition(Matrix mtx) {
+        assert mtx != null;
+
+        rows = mtx.rowSize();
+
+        int min = Math.min(mtx.rowSize(), mtx.columnSize());
+
+        cols = mtx.columnSize();
+
+        mType = like(mtx, 1, 1);
+
+        Matrix qTmp = copy(mtx);
+
+        boolean fullRank = true;
+
+        r = like(mtx, min, cols);
+
+        for (int i = 0; i < min; i++) {
+            Vector qi = qTmp.viewColumn(i);
+
+            double alpha = qi.kNorm(2);
+
+            if (Math.abs(alpha) > Double.MIN_VALUE)
+                qi.map(Functions.div(alpha));
+            else {
+                checkDouble(alpha);
+
+                fullRank = false;
+            }
+
+            r.set(i, i, alpha);
+
+            for (int j = i + 1; j < cols; j++) {
+                Vector qj = qTmp.viewColumn(j);
+
+                double norm = qj.kNorm(2);
+
+                if (Math.abs(norm) > Double.MIN_VALUE) {
+                    double beta = qi.dot(qj);
+
+                    r.set(i, j, beta);
+
+                    if (j < min)
+                        qj.map(qi, Functions.plusMult(-beta));
+                }
+                else
+                    checkDouble(norm);
+            }
+        }
+
+        if (cols > min)
+            q = qTmp.viewPart(0, rows, 0, min).copy();
+        else
+            q = qTmp;
+
+        this.fullRank = fullRank;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void destroy() {
+        q.destroy();
+        r.destroy();
+        mType.destroy();
+    }
+
+    /**
+     * Gets orthogonal factor {@code Q}.
+     */
+    public Matrix getQ() {
+        return q;
+    }
+
+    /**
+     * Gets triangular factor {@code R}.
+     */
+    public Matrix getR() {
+        return r;
+    }
+
+    /**
+     * Returns whether the matrix {@code A} has full rank.
+     *
+     * @return true if {@code R}, and hence {@code A} , has full rank.
+     */
+    public boolean hasFullRank() {
+        return fullRank;
+    }
+
+    /**
+     * Least squares solution of {@code A*X = B}; {@code returns X}.
+     *
+     * @param mtx A matrix with as many rows as {@code A} and any number of cols.
+     * @return {@code X<} that minimizes the two norm of {@code Q*R*X - B}.
+     * @throws IllegalArgumentException if {@code B.rows() != A.rows()}.
+     */
+    public Matrix solve(Matrix mtx) {
+        if (mtx.rowSize() != rows)
+            throw new IllegalArgumentException("Matrix row dimensions must agree.");
+
+        int cols = mtx.columnSize();
+
+        Matrix x = like(mType, this.cols, cols);
+
+        Matrix qt = getQ().transpose();
+        Matrix y = qt.times(mtx);
+
+        Matrix r = getR();
+
+        for (int k = Math.min(this.cols, rows) - 1; k > 0; k--) {
+            // X[k,] = Y[k,] / R[k,k], note that X[k,] starts with 0 so += is same as =
+            x.viewRow(k).map(y.viewRow(k), Functions.plusMult(1 / r.get(k, k)));
+
+            // Y[0:(k-1),] -= R[0:(k-1),k] * X[k,]
+            Vector rCol = r.viewColumn(k).viewPart(0, k);
+
+            for (int c = 0; c < cols; c++)
+                y.viewColumn(c).viewPart(0, k).map(rCol, Functions.plusMult(-x.get(k, c)));
+        }
+
+        return x;
+    }
+
+    /**
+     * Returns a rough string rendition of a QR.
+     */
+    @Override public String toString() {
+        return String.format("QR(%d x %d, fullRank=%s)", rows, cols, hasFullRank());
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java
new file mode 100644
index 0000000..75eb206
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java
@@ -0,0 +1,620 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.decompositions;
+
+import org.apache.ignite.math.Algebra;
+import org.apache.ignite.math.Matrix;
+
+/**
+ * Compute a singular value decomposition (SVD) of {@code (l x k)} matrix {@code m}.
+ * <p>This decomposition can be thought
+ * as an extension of {@link EigenDecomposition} to rectangular matrices. The factorization we get is following:</p>
+ * <p>{@code m = u * s * v^{*}}, where</p>
+ * <ul><li>{@code u} is a real or complex unitary matrix.</li>
+ * <li>{@code s} is a rectangular diagonal matrix with non-negative real numbers on diagonal
+ * (these numbers are singular values of {@code m}).</li>
+ * <li>{@code v} is a real or complex unitary matrix.</li></ul>
+ * <p>If {@code m} is real then {@code u} and {@code v} are also real.</p>
+ * <p>See also: <a href="https://en.wikipedia.org/wiki/Singular_value_decomposition">Wikipedia article on SVD</a>.</p>
+ * <p>Note: complex case is currently not supported.</p>
+ */
+public class SingularValueDecomposition extends DecompositionSupport {
+    // U and V.
+    /** */
+    private final double[][] u;
+    /** */
+    private final double[][] v;
+
+    /** Singular values. */
+    private final double[] s;
+
+    /** Row dimension. */
+    private final int m;
+    /** Column dimension. */
+    private final int n;
+
+    /** */
+    private Matrix arg;
+
+    /** */
+    private boolean transpositionNeeded;
+
+    /**
+     * Singular value decomposition object.
+     *
+     * @param arg A rectangular matrix.
+     */
+    public SingularValueDecomposition(Matrix arg) {
+        assert arg != null;
+
+        this.arg = arg;
+
+        if (arg.rowSize() < arg.columnSize())
+            transpositionNeeded = true;
+
+        double[][] a;
+
+        if (transpositionNeeded) {
+            // Use the transpose matrix.
+            m = arg.columnSize();
+            n = arg.rowSize();
+
+            a = new double[m][n];
+
+            for (int i = 0; i < m; i++)
+                for (int j = 0; j < n; j++)
+                    a[i][j] = arg.get(j, i);
+        }
+        else {
+            m = arg.rowSize();
+            n = arg.columnSize();
+
+            a = new double[m][n];
+
+            for (int i = 0; i < m; i++)
+                for (int j = 0; j < n; j++)
+                    a[i][j] = arg.get(i, j);
+        }
+
+        int nu = Math.min(m, n);
+
+        s = new double[Math.min(m + 1, n)];
+        u = new double[m][nu];
+        v = new double[n][n];
+
+        double[] e = new double[n];
+        double[] work = new double[m];
+
+        int nct = Math.min(m - 1, n);
+        int nrt = Math.max(0, Math.min(n - 2, m));
+
+        for (int k = 0; k < Math.max(nct, nrt); k++) {
+            if (k < nct) {
+                // Compute the transformation for the k-th column and
+                // place the k-th diagonal in s[k]. Compute 2-norm of k-th
+                // column without under/overflow.
+                s[k] = 0;
+
+                for (int i = k; i < m; i++)
+                    s[k] = Algebra.hypot(s[k], a[i][k]);
+
+                if (s[k] != 0.0) {
+                    if (a[k][k] < 0.0)
+                        s[k] = -s[k];
+
+                    for (int i = k; i < m; i++)
+                        a[i][k] /= s[k];
+
+                    a[k][k] += 1.0;
+                }
+
+                s[k] = -s[k];
+            }
+
+            for (int j = k + 1; j < n; j++) {
+                if (k < nct && s[k] != 0.0) {
+                    // Apply the transformation.
+                    double t = 0;
+
+                    for (int i = k; i < m; i++)
+                        t += a[i][k] * a[i][j];
+
+                    t = -t / a[k][k];
+
+                    for (int i = k; i < m; i++)
+                        a[i][j] += t * a[i][k];
+                }
+
+                // Place the k-th row of A into e for the
+                // subsequent calculation of the row transformation.
+                e[j] = a[k][j];
+            }
+
+            if (k < nct)
+                // Place the transformation in U for subsequent back
+                // multiplication.
+                for (int i = k; i < m; i++)
+                    u[i][k] = a[i][k];
+
+            if (k < nrt) {
+                // Compute the k-th row transformation and place the
+                // k-th super-diagonal in e[k].
+                // Compute 2-norm without under/overflow.
+                e[k] = 0;
+
+                for (int i = k + 1; i < n; i++)
+                    e[k] = Algebra.hypot(e[k], e[i]);
+
+                if (e[k] != 0.0) {
+                    if (e[k + 1] < 0.0)
+                        e[k] = -e[k];
+
+                    for (int i = k + 1; i < n; i++)
+                        e[i] /= e[k];
+
+                    e[k + 1] += 1.0;
+                }
+
+                e[k] = -e[k];
+
+                if (k + 1 < m && e[k] != 0.0) {
+                    // Apply the transformation.
+                    for (int i = k + 1; i < m; i++)
+                        work[i] = 0.0;
+
+                    for (int j = k + 1; j < n; j++)
+                        for (int i = k + 1; i < m; i++)
+                            work[i] += e[j] * a[i][j];
+
+                    for (int j = k + 1; j < n; j++) {
+                        double t = -e[j] / e[k + 1];
+
+                        for (int i = k + 1; i < m; i++)
+                            a[i][j] += t * work[i];
+                    }
+                }
+
+                // Place the transformation in V for subsequent
+                // back multiplication.
+                for (int i = k + 1; i < n; i++)
+                    v[i][k] = e[i];
+            }
+        }
+
+        // Set up the final bi-diagonal matrix or order p.
+        int p = Math.min(n, m + 1);
+
+        if (nct < n)
+            s[nct] = a[nct][nct];
+
+        if (m < p)
+            s[p - 1] = 0.0;
+
+        if (nrt + 1 < p)
+            e[nrt] = a[nrt][p - 1];
+
+        e[p - 1] = 0.0;
+
+        // Generate U.
+        for (int j = nct; j < nu; j++) {
+            for (int i = 0; i < m; i++)
+                u[i][j] = 0.0;
+
+            u[j][j] = 1.0;
+        }
+
+        for (int k = nct - 1; k >= 0; k--) {
+            if (s[k] != 0.0) {
+                for (int j = k + 1; j < nu; j++) {
+                    double t = 0;
+
+                    for (int i = k; i < m; i++)
+                        t += u[i][k] * u[i][j];
+
+                    t = -t / u[k][k];
+
+                    for (int i = k; i < m; i++)
+                        u[i][j] += t * u[i][k];
+                }
+
+                for (int i = k; i < m; i++)
+                    u[i][k] = -u[i][k];
+
+                u[k][k] = 1.0 + u[k][k];
+
+                for (int i = 0; i < k - 1; i++)
+                    u[i][k] = 0.0;
+            }
+            else {
+                for (int i = 0; i < m; i++)
+                    u[i][k] = 0.0;
+
+                u[k][k] = 1.0;
+            }
+        }
+
+        // Generate V.
+        for (int k = n - 1; k >= 0; k--) {
+            if (k < nrt && e[k] != 0.0) {
+                for (int j = k + 1; j < nu; j++) {
+                    double t = 0;
+
+                    for (int i = k + 1; i < n; i++)
+                        t += v[i][k] * v[i][j];
+
+                    t = -t / v[k + 1][k];
+
+                    for (int i = k + 1; i < n; i++)
+                        v[i][j] += t * v[i][k];
+                }
+            }
+
+            for (int i = 0; i < n; i++)
+                v[i][k] = 0.0;
+
+            v[k][k] = 1.0;
+        }
+
+        // Main iteration loop for the singular values.
+        int pp = p - 1;
+        int iter = 0;
+
+        double eps = Math.pow(2.0, -52.0);
+        double tiny = Math.pow(2.0, -966.0);
+
+        while (p > 0) {
+            int k;
+
+            for (k = p - 2; k >= -1; k--) {
+                if (k == -1)
+                    break;
+
+                if (Math.abs(e[k]) <= tiny + eps * (Math.abs(s[k]) + Math.abs(s[k + 1]))) {
+                    e[k] = 0.0;
+
+                    break;
+                }
+            }
+
+            int kase;
+
+            if (k == p - 2)
+                kase = 4;
+            else {
+                int ks;
+
+                for (ks = p - 1; ks >= k; ks--) {
+                    if (ks == k)
+                        break;
+
+                    double t =
+                        (ks != p ? Math.abs(e[ks]) : 0.) +
+                            (ks != k + 1 ? Math.abs(e[ks - 1]) : 0.);
+
+                    if (Math.abs(s[ks]) <= tiny + eps * t) {
+                        s[ks] = 0.0;
+
+                        break;
+                    }
+                }
+
+                if (ks == k)
+                    kase = 3;
+                else if (ks == p - 1)
+                    kase = 1;
+                else {
+                    kase = 2;
+
+                    k = ks;
+                }
+            }
+
+            k++;
+
+            // Perform the task indicated by kase.
+            switch (kase) {
+                // Deflate negligible s(p).
+                case 1: {
+                    double f = e[p - 2];
+
+                    e[p - 2] = 0.0;
+
+                    for (int j = p - 2; j >= k; j--) {
+                        double t = Algebra.hypot(s[j], f);
+                        double cs = s[j] / t;
+                        double sn = f / t;
+
+                        s[j] = t;
+
+                        if (j != k) {
+                            f = -sn * e[j - 1];
+                            e[j - 1] = cs * e[j - 1];
+                        }
+
+                        for (int i = 0; i < n; i++) {
+                            t = cs * v[i][j] + sn * v[i][p - 1];
+
+                            v[i][p - 1] = -sn * v[i][j] + cs * v[i][p - 1];
+                            v[i][j] = t;
+                        }
+                    }
+                }
+
+                break;
+
+                // Split at negligible s(k).
+                case 2: {
+                    double f = e[k - 1];
+                    e[k - 1] = 0.0;
+
+                    for (int j = k; j < p; j++) {
+                        double t = Algebra.hypot(s[j], f);
+                        double cs = s[j] / t;
+                        double sn = f / t;
+
+                        s[j] = t;
+                        f = -sn * e[j];
+                        e[j] = cs * e[j];
+
+                        for (int i = 0; i < m; i++) {
+                            t = cs * u[i][j] + sn * u[i][k - 1];
+
+                            u[i][k - 1] = -sn * u[i][j] + cs * u[i][k - 1];
+                            u[i][j] = t;
+                        }
+                    }
+                }
+
+                break;
+
+                // Perform one qr step.
+                case 3: {
+                    // Calculate the shift.
+                    double scale = Math.max(Math.max(Math.max(Math.max(
+                        Math.abs(s[p - 1]), Math.abs(s[p - 2])), Math.abs(e[p - 2])),
+                        Math.abs(s[k])), Math.abs(e[k]));
+
+                    double sp = s[p - 1] / scale;
+                    double spm1 = s[p - 2] / scale;
+                    double epm1 = e[p - 2] / scale;
+                    double sk = s[k] / scale;
+                    double ek = e[k] / scale;
+                    double b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2.0;
+                    double c = sp * epm1 * sp * epm1;
+                    double shift = 0.0;
+
+                    if (b != 0.0 || c != 0.0) {
+                        shift = Math.sqrt(b * b + c);
+
+                        if (b < 0.0)
+                            shift = -shift;
+
+                        shift = c / (b + shift);
+                    }
+
+                    double f = (sk + sp) * (sk - sp) + shift;
+                    double g = sk * ek;
+
+                    // Chase zeros.
+                    for (int j = k; j < p - 1; j++) {
+                        double t = Algebra.hypot(f, g);
+                        double cs = f / t;
+                        double sn = g / t;
+
+                        if (j != k)
+                            e[j - 1] = t;
+
+                        f = cs * s[j] + sn * e[j];
+                        e[j] = cs * e[j] - sn * s[j];
+                        g = sn * s[j + 1];
+                        s[j + 1] = cs * s[j + 1];
+
+                        for (int i = 0; i < n; i++) {
+                            t = cs * v[i][j] + sn * v[i][j + 1];
+
+                            v[i][j + 1] = -sn * v[i][j] + cs * v[i][j + 1];
+                            v[i][j] = t;
+                        }
+
+                        t = Algebra.hypot(f, g);
+                        cs = f / t;
+                        sn = g / t;
+                        s[j] = t;
+                        f = cs * e[j] + sn * s[j + 1];
+                        s[j + 1] = -sn * e[j] + cs * s[j + 1];
+                        g = sn * e[j + 1];
+                        e[j + 1] = cs * e[j + 1];
+
+                        if (j < m - 1)
+                            for (int i = 0; i < m; i++) {
+                                t = cs * u[i][j] + sn * u[i][j + 1];
+
+                                u[i][j + 1] = -sn * u[i][j] + cs * u[i][j + 1];
+                                u[i][j] = t;
+                            }
+                    }
+
+                    e[p - 2] = f;
+                    iter = iter + 1;
+                }
+
+                break;
+
+                // Convergence.
+                case 4: {
+                    // Make the singular values positive.
+                    if (s[k] <= 0.0) {
+                        s[k] = s[k] < 0.0 ? -s[k] : 0.0;
+
+                        for (int i = 0; i <= pp; i++)
+                            v[i][k] = -v[i][k];
+                    }
+
+                    // Order the singular values.
+                    while (k < pp) {
+                        if (s[k] >= s[k + 1])
+                            break;
+
+                        double t = s[k];
+
+                        s[k] = s[k + 1];
+                        s[k + 1] = t;
+
+                        if (k < n - 1)
+                            for (int i = 0; i < n; i++) {
+                                t = v[i][k + 1];
+
+                                v[i][k + 1] = v[i][k];
+                                v[i][k] = t;
+                            }
+
+                        if (k < m - 1)
+                            for (int i = 0; i < m; i++) {
+                                t = u[i][k + 1];
+
+                                u[i][k + 1] = u[i][k];
+                                u[i][k] = t;
+                            }
+
+                        k++;
+                    }
+
+                    iter = 0;
+                    p--;
+                }
+
+                break;
+
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+    }
+
+    /**
+     * Gets the two norm condition number, which is {@code max(S) / min(S)} .
+     */
+    public double cond() {
+        return s[0] / s[Math.min(m, n) - 1];
+    }
+
+    /**
+     * @return the diagonal matrix of singular values.
+     */
+    public Matrix getS() {
+        double[][] s = new double[n][n];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++)
+                s[i][j] = 0.0;
+
+            s[i][i] = this.s[i];
+        }
+
+        return like(arg, n, n).assign(s);
+    }
+
+    /**
+     * Gets the diagonal of {@code S}, which is a one-dimensional array of
+     * singular values.
+     *
+     * @return diagonal of {@code S}.
+     */
+    public double[] getSingularValues() {
+        return s;
+    }
+
+    /**
+     * Gets the left singular vectors {@code U}.
+     *
+     * @return {@code U}
+     */
+    public Matrix getU() {
+        if (transpositionNeeded)
+            return like(arg, v.length, v.length).assign(v);
+        else {
+            int numCols = Math.min(m + 1, n);
+
+            Matrix r = like(arg, m, numCols);
+
+            for (int i = 0; i < m; i++)
+                for (int j = 0; j < numCols; j++)
+                    r.set(i, j, u[i][j]);
+
+            return r;
+        }
+    }
+
+    /**
+     * Gets the right singular vectors {@code V}.
+     *
+     * @return {@code V}
+     */
+    public Matrix getV() {
+        if (transpositionNeeded) {
+            int numCols = Math.min(m + 1, n);
+
+            Matrix r = like(arg, m, numCols);
+
+            for (int i = 0; i < m; i++)
+                for (int j = 0; j < numCols; j++)
+                    r.set(i, j, u[i][j]);
+
+            return r;
+        }
+        else
+            return like(arg, v.length, v.length).assign(v);
+    }
+
+    /**
+     * Gets the two norm, which is {@code max(S)}.
+     */
+    public double norm2() {
+        return s[0];
+    }
+
+    /**
+     * Gets effective numerical matrix rank.
+     */
+    public int rank() {
+        double eps = Math.pow(2.0, -52.0);
+        double tol = Math.max(m, n) * s[0] * eps;
+        int r = 0;
+
+        for (double value : s)
+            if (value > tol)
+                r++;
+
+        return r;
+    }
+
+    /**
+     * Gets [n × n] covariance matrix.
+     *
+     * @param minSingularVal Value below which singular values are ignored.
+     */
+    Matrix getCovariance(double minSingularVal) {
+        Matrix j = like(arg, s.length, s.length);
+        Matrix vMat = like(arg, v.length, v.length).assign(v);
+
+        for (int i = 0; i < s.length; i++)
+            j.set(i, i, s[i] >= minSingularVal ? 1 / (s[i] * s[i]) : 0.0);
+
+        return vMat.times(j).times(vMat.transpose());
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/package-info.java
new file mode 100644
index 0000000..dcfa0f8
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <!-- Package description. -->
+ * Contains matrix decompositions for distributed code algebra.
+ */
+package org.apache.ignite.math.decompositions;

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java
new file mode 100644
index 0000000..fc87a27
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * Indicates a cardinality mismatch in matrix or vector operations.
+ */
+public class CardinalityException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * Creates new cardinality violation exception.
+     *
+     * @param exp Expected cardinality.
+     * @param act Actual cardinality.
+     */
+    public CardinalityException(int exp, int act) {
+        super("Cardinality violation [expected=" + exp + ", actual=" + act + "]");
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java
new file mode 100644
index 0000000..7670caf
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * This exception is used to indicate any error condition accessing matrix elements by invalid column index.
+ */
+public class ColumnIndexException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * @param idx Index value that caused this exception.
+     */
+    public ColumnIndexException(int idx) {
+        super("Invalid (out of bound) column index: " + idx);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/IndexException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/IndexException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/IndexException.java
new file mode 100644
index 0000000..9ada706
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/IndexException.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * Indicates an invalid, i.e. out of bound, index on matrix or vector operations.
+ */
+public class IndexException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * @param idx Index value that caused this exception.
+     */
+    public IndexException(int idx) {
+        super("Invalid (out of bound) index: " + idx);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java
new file mode 100644
index 0000000..b6017c2
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java
@@ -0,0 +1,20 @@
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * This exception is used to indicate error condition of matrix elements failing the positivity check.
+ */
+public class NonPositiveDefiniteMatrixException extends IgniteException {
+    /**
+     * Construct an exception.
+     *
+     * @param wrong Value that fails the positivity check.
+     * @param idx Row (and column) index.
+     * @param threshold Absolute positivity threshold.
+     */
+    public NonPositiveDefiniteMatrixException(double wrong, int idx, double threshold) {
+        super("Matrix must be positive, wrong element located on diagonal with index "
+            + idx + " and has value " + wrong + " with this threshold " + threshold);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java
new file mode 100644
index 0000000..8b4cbdb
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java
@@ -0,0 +1,18 @@
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * This exception is used to indicate error condition of matrix failing the symmetry check.
+ */
+public class NonSymmetricMatrixException extends IgniteException {
+    /**
+     * @param row Row.
+     * @param col Column.
+     * @param threshold Threshold.
+     */
+    public NonSymmetricMatrixException(int row, int col, double threshold) {
+        super("Symmetric matrix expected, the symmetry is broken on row "
+            + row + " and col " + col + " with this threshold " + threshold);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java
new file mode 100644
index 0000000..f74ae2c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * This exception is used to indicate any error condition accessing matrix elements by invalid row index.
+ */
+public class RowIndexException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * @param idx Index value that caused this exception.
+     */
+    public RowIndexException(int idx) {
+        super("Invalid (out of bound) row index: " + idx);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java
new file mode 100644
index 0000000..4ed3410
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * Exception to be thrown when a non-singular matrix is expected.
+ */
+public class SingularMatrixException extends IgniteException {
+    /** */
+    public SingularMatrixException() {
+        super("Regular (or non-singular) matrix expected.");
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java
new file mode 100644
index 0000000..3e6498a
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * Indicates that no provider has been found for a given vector or matrix flavor.
+ */
+public class UnknownProviderException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * @param flv Flavor (a.k.a. operation performance hints) that has no registered provider for.
+     */
+    public UnknownProviderException(String flv) {
+        super("No provider has been found for the flavor: " + flv);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java
new file mode 100644
index 0000000..be5264c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.exceptions;
+
+import org.apache.ignite.IgniteException;
+
+/**
+ * Indicate that a specific operation is not supported by the underlying implementation.
+ * In some cases, an operation may be unsupported only in certain cases where, for example,
+ * it could not be deterministically completed in polynomial time.
+ */
+public class UnsupportedOperationException extends IgniteException {
+    /** */
+    private static final long serialVersionUID = 0L;
+
+    /**
+     * @param errMsg Error message.
+     */
+    public UnsupportedOperationException(String errMsg) {
+        super(errMsg);
+    }
+
+    /**
+     *
+     */
+    public UnsupportedOperationException() {
+        this("Unsupported operation.");
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/exceptions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/exceptions/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/package-info.java
new file mode 100644
index 0000000..83f3fa4
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/exceptions/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <!-- Package description. -->
+ * Contains exceptions for distributed code algebra.
+ */
+package org.apache.ignite.math.exceptions;
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/Functions.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/Functions.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/Functions.java
new file mode 100644
index 0000000..7100908
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/Functions.java
@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+/**
+ * Compatibility with Apache Mahout.
+ */
+public final class Functions {
+    /** Function that returns {@code Math.abs(a)}. */
+    public static final IgniteDoubleFunction<Double> ABS = Math::abs;
+
+    /** Function that returns its argument. */
+    public static final IgniteDoubleFunction<Double> IDENTITY = (a) -> a;
+
+    /** Function that returns {@code Math.log(a) / Math.log(2)}. */
+    public static final IgniteDoubleFunction<Double> LOG2 = (a) -> Math.log(a) * 1.4426950408889634;
+
+    /** Function that returns {@code -a}. */
+    public static final IgniteDoubleFunction<Double> NEGATE = (a) -> -a;
+
+    /** Function that returns {@code  a < 0 ? -1 : a > 0 ? 1 : 0 }. */
+    public static final IgniteDoubleFunction<Double> SIGN = (a) -> a < 0.0 ? -1.0 : a > 0.0 ? 1.0 : 0.0;
+
+    /** Function that returns {@code a * a}. */
+    public static final IgniteDoubleFunction<Double> SQUARE = (a) -> a * a;
+
+    /** Function that returns {@code  1 / (1 + exp(-a) } */
+    public static final IgniteDoubleFunction<Double> SIGMOID = (a) -> 1.0 / (1.0 + Math.exp(-a));
+
+    /** Function that returns {@code  1 / a } */
+    public static final IgniteDoubleFunction<Double> INV = (a) -> 1.0 / a;
+
+    /** Function that returns {@code  a * (1-a) } */
+    public static final IgniteDoubleFunction<Double> SIGMOIDGRADIENT = (a) -> a * (1.0 - a);
+
+    /** Function that returns {@code a % b}. */
+    public static final IgniteBiFunction<Double, Double, Double> MOD = (a, b) -> a % b;
+
+    /** Function that returns {@code a * b}. */
+    public static final IgniteBiFunction<Double, Double, Double> MULT = (a, b) -> a * b;
+
+    /** Function that returns {@code Math.log(a) / Math.log(b)}. */
+    public static final IgniteBiFunction<Double, Double, Double> LG = (a, b) -> Math.log(a) / Math.log(b);
+
+    /** Function that returns {@code a + b}. */
+    public static final IgniteBiFunction<Double, Double, Double> PLUS = (a, b) -> a + b;
+
+    /** Function that returns {@code a - b}. */
+    public static final IgniteBiFunction<Double, Double, Double> MINUS = (a, b) -> a - b;
+
+    /** Function that returns {@code abs(a - b)}. */
+    public static final IgniteBiFunction<Double, Double, Double> MINUS_ABS = (a, b) -> Math.abs(a - b);
+
+    /** Function that returns {@code max(abs(a), abs(b))}. */
+    public static final IgniteBiFunction<Double, Double, Double> MAX_ABS = (a, b) -> Math.max(Math.abs(a), Math.abs(b));
+
+    /** Function that returns {@code min(abs(a), abs(b))}. */
+    public static final IgniteBiFunction<Double, Double, Double> MIN_ABS = (a, b) -> Math.min(Math.abs(a), Math.abs(b));
+
+    /** Function that returns {@code Math.abs(a) + Math.abs(b)}. */
+    public static final IgniteBiFunction<Double, Double, Double> PLUS_ABS = (a, b) -> Math.abs(a) + Math.abs(b);
+
+    /** Function that returns {@code (a - b) * (a - b)} */
+    public static final IgniteBiFunction<Double, Double, Double> MINUS_SQUARED = (a, b) -> (a - b) * (a - b);
+
+    /**
+     * Function that returns {@code a &lt; b ? -1 : a &gt; b ? 1 : 0}.
+     */
+    public static final IgniteBiFunction<Double, Double, Double> COMPARE = (a, b) -> a < b ? -1.0 : a > b ? 1.0 : 0.0;
+
+    /**
+     * Function that returns {@code a + b}. {@code a} is a variable, {@code b} is fixed.
+     *
+     * @param b
+     */
+    public static IgniteDoubleFunction<Double> plus(final double b) {
+        return (a) -> a + b;
+    }
+
+    /**
+     * Function that returns {@code a * b}. {@code a} is a variable, {@code b} is fixed.
+     *
+     * @param b
+     */
+    public static IgniteDoubleFunction<Double> mult(final double b) {
+        return (a) -> a * b;
+    }
+
+    /** Function that returns {@code a / b}. {@code a} is a variable, {@code b} is fixed. */
+    public static IgniteDoubleFunction<Double> div(double b) {
+        return mult(1 / b);
+    }
+
+    /**
+     * Function that returns {@code a + b*constant}. {@code a} and {@code b} are variables,
+     * {@code constant} is fixed.
+     */
+    public static IgniteBiFunction<Double, Double, Double> plusMult(double constant) {
+        return (a, b) -> a + b * constant;
+    }
+
+    /**
+     * Function that returns {@code a - b*constant}. {@code a} and {@code b} are variables,
+     * {@code constant} is fixed.
+     */
+    public static IgniteBiFunction<Double, Double, Double> minusMult(double constant) {
+        return (a, b) -> a - b * constant;
+    }
+
+    /**
+     * @param b
+     */
+    public static IgniteDoubleFunction<Double> pow(final double b) {
+        return (a) -> {
+            if (b == 2)
+                return a * a;
+            else
+                return Math.pow(a, b);
+        };
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java
new file mode 100644
index 0000000..22e8274
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java
@@ -0,0 +1,12 @@
+package org.apache.ignite.math.functions;
+
+import java.io.Serializable;
+import java.util.function.BiConsumer;
+
+/**
+ * Serializable binary consumer.
+ *
+ * @see java.util.function.BiConsumer
+ */
+public interface IgniteBiConsumer<T, U> extends BiConsumer<T, U>, Serializable {
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java
new file mode 100644
index 0000000..9d9c147
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+import java.io.Serializable;
+import java.util.function.BiFunction;
+
+/**
+ * Serializable binary function.
+ *
+ * @see java.util.function.BiFunction
+ */
+public interface IgniteBiFunction<A, B, T> extends BiFunction<A, B, T>, Serializable {
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java
new file mode 100644
index 0000000..1f7ca07
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+import java.io.Serializable;
+import java.util.function.Consumer;
+
+/**
+ * Serializable consumer.
+ *
+ * @see java.util.function.Consumer
+ */
+public interface IgniteConsumer<T> extends Consumer<T>, Serializable {
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java
new file mode 100644
index 0000000..7a23d50
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+import java.io.Serializable;
+import java.util.function.DoubleFunction;
+
+/**
+ * Serializable double function.
+ *
+ * @see java.util.function.DoubleFunction
+ */
+public interface IgniteDoubleFunction<Double> extends DoubleFunction<Double>, Serializable {
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java
new file mode 100644
index 0000000..cfe89a4
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+import java.io.Serializable;
+import java.util.function.Function;
+
+/**
+ * Serializable function.
+ *
+ * @see java.util.function.Function
+ */
+public interface IgniteFunction<T, R> extends Function<T, R>, Serializable {
+
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java
new file mode 100644
index 0000000..e5d69c7
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java
@@ -0,0 +1,25 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+/**
+ * Setter function for the vector.
+ */
+public interface IntDoubleToVoidFunction extends IgniteBiConsumer<Integer, Double> {
+
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java
new file mode 100644
index 0000000..cad8c3c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+import java.io.Serializable;
+
+/**
+ * Setter function for matrices.
+ */
+public interface IntIntDoubleToVoidFunction extends Serializable {
+    /** */
+    public void apply(int x, int y, double v);
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java
new file mode 100644
index 0000000..b31d9f9
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java
@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.functions;
+
+/**
+ * Getters functions for matrices.
+ */
+public interface IntIntToDoubleFunction extends IgniteBiFunction<Integer, Integer, Double> {
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/functions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/functions/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/functions/package-info.java
new file mode 100644
index 0000000..133e62c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/functions/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <!-- Package description. -->
+ * Contains serializable functions for distributed code algebra.
+ */
+package org.apache.ignite.math.functions;
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/CacheUtils.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/CacheUtils.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/CacheUtils.java
new file mode 100644
index 0000000..df33895
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/CacheUtils.java
@@ -0,0 +1,356 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.math.impls;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import javax.cache.Cache;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.cache.affinity.Affinity;
+import org.apache.ignite.cache.query.ScanQuery;
+import org.apache.ignite.cluster.ClusterGroup;
+import org.apache.ignite.cluster.ClusterNode;
+import org.apache.ignite.lang.IgniteCallable;
+import org.apache.ignite.lang.IgniteRunnable;
+import org.apache.ignite.math.KeyMapper;
+import org.apache.ignite.math.ValueMapper;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteConsumer;
+import org.apache.ignite.math.functions.IgniteFunction;
+
+/**
+ * Distribution-related misc. support.
+ */
+public class CacheUtils {
+    /**
+     * Cache entry support.
+     *
+     * @param <K>
+     * @param <V>
+     */
+    public static class CacheEntry<K, V> {
+        /** */
+        private Cache.Entry<K, V> entry;
+        /** */
+        private IgniteCache<K, V> cache;
+
+        /**
+         * @param entry Original cache entry.
+         * @param cache Cache instance.
+         */
+        CacheEntry(Cache.Entry<K, V> entry, IgniteCache<K, V> cache) {
+            this.entry = entry;
+            this.cache = cache;
+        }
+
+        /**
+         *
+         *
+         */
+        public Cache.Entry<K, V> entry() {
+            return entry;
+        }
+
+        /**
+         *
+         *
+         */
+        public IgniteCache<K, V> cache() {
+            return cache;
+        }
+    }
+
+    /**
+     * Gets local Ignite instance.
+     */
+    public static Ignite ignite() {
+        return Ignition.localIgnite();
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param k Key into the cache.
+     * @param <K> Key type.
+     * @return Cluster group for given key.
+     */
+    public static <K> ClusterGroup groupForKey(String cacheName, K k) {
+        return ignite().cluster().forNode(ignite().affinity(cacheName).mapKeyToNode(k));
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param keyMapper {@link KeyMapper} to validate cache key.
+     * @param valMapper {@link ValueMapper} to obtain double value for given cache key.
+     * @param <K> Cache key object type.
+     * @param <V> Cache value object type.
+     * @return Sum of the values obtained for valid keys.
+     */
+    public static <K, V> double sum(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper) {
+        Collection<Double> subSums = fold(cacheName, (CacheEntry<K, V> ce, Double acc) -> {
+            if (keyMapper.isValid(ce.entry().getKey())) {
+                double v = valMapper.toDouble(ce.entry().getValue());
+
+                return acc == null ? v : acc + v;
+            }
+            else
+                return acc;
+        });
+
+        return sum(subSums);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @return Sum obtained using sparse logic.
+     */
+    public static <K, V> double sparseSum(String cacheName) {
+        Collection<Double> subSums = fold(cacheName, (CacheEntry<Integer, Map<Integer, Double>> ce, Double acc) -> {
+            Map<Integer, Double> map = ce.entry().getValue();
+
+            double sum = sum(map.values());
+
+            return acc == null ? sum : acc + sum;
+        });
+
+        return sum(subSums);
+    }
+
+    /**
+     * @param c {@link Collection} of double values to sum.
+     * @return Sum of the values.
+     */
+    private static double sum(Collection<Double> c) {
+        double sum = 0.0;
+
+        for (double d : c)
+            sum += d;
+
+        return sum;
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param keyMapper {@link KeyMapper} to validate cache key.
+     * @param valMapper {@link ValueMapper} to obtain double value for given cache key.
+     * @param <K> Cache key object type.
+     * @param <V> Cache value object type.
+     * @return Minimum value for valid keys.
+     */
+    public static <K, V> double min(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper) {
+        Collection<Double> mins = fold(cacheName, (CacheEntry<K, V> ce, Double acc) -> {
+            if (keyMapper.isValid(ce.entry().getKey())) {
+                double v = valMapper.toDouble(ce.entry().getValue());
+
+                if (acc == null)
+                    return v;
+                else
+                    return Math.min(acc, v);
+            }
+            else
+                return acc;
+        });
+
+        return Collections.min(mins);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @return Minimum value obtained using sparse logic.
+     */
+    public static <K, V> double sparseMin(String cacheName) {
+        Collection<Double> mins = fold(cacheName, (CacheEntry<Integer, Map<Integer, Double>> ce, Double acc) -> {
+            Map<Integer, Double> map = ce.entry().getValue();
+
+            double min = Collections.min(map.values());
+
+            if (acc == null)
+                return min;
+            else
+                return Math.min(acc, min);
+        });
+
+        return Collections.min(mins);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @return Maximum value obtained using sparse logic.
+     */
+    public static <K, V> double sparseMax(String cacheName) {
+        Collection<Double> maxes = fold(cacheName, (CacheEntry<Integer, Map<Integer, Double>> ce, Double acc) -> {
+            Map<Integer, Double> map = ce.entry().getValue();
+
+            double max = Collections.max(map.values());
+
+            if (acc == null)
+                return max;
+            else
+                return Math.max(acc, max);
+        });
+
+        return Collections.max(maxes);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param keyMapper {@link KeyMapper} to validate cache key.
+     * @param valMapper {@link ValueMapper} to obtain double value for given cache key.
+     * @param <K> Cache key object type.
+     * @param <V> Cache value object type.
+     * @return Maximum value for valid keys.
+     */
+    public static <K, V> double max(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper) {
+        Collection<Double> maxes = fold(cacheName, (CacheEntry<K, V> ce, Double acc) -> {
+            if (keyMapper.isValid(ce.entry().getKey())) {
+                double v = valMapper.toDouble(ce.entry().getValue());
+
+                if (acc == null)
+                    return v;
+                else
+                    return Math.max(acc, v);
+            }
+            else
+                return acc;
+        });
+
+        return Collections.max(maxes);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param keyMapper {@link KeyMapper} to validate cache key.
+     * @param valMapper {@link ValueMapper} to obtain double value for given cache key.
+     * @param mapper Mapping {@link IgniteFunction}.
+     * @param <K> Cache key object type.
+     * @param <V> Cache value object type.
+     */
+    public static <K, V> void map(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper,
+        IgniteFunction<Double, Double> mapper) {
+        foreach(cacheName, (CacheEntry<K, V> ce) -> {
+            K k = ce.entry().getKey();
+
+            if (keyMapper.isValid(k))
+                // Actual assignment.
+                ce.cache().put(k, valMapper.fromDouble(mapper.apply(valMapper.toDouble(ce.entry().getValue()))));
+        });
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param mapper Mapping {@link IgniteFunction}.
+     */
+    public static <K, V> void sparseMap(String cacheName, IgniteFunction<Double, Double> mapper) {
+        foreach(cacheName, (CacheEntry<Integer, Map<Integer, Double>> ce) -> {
+            Integer k = ce.entry().getKey();
+            Map<Integer, Double> v = ce.entry().getValue();
+
+            for (Map.Entry<Integer, Double> e : v.entrySet())
+                e.setValue(mapper.apply(e.getValue()));
+
+            ce.cache().put(k, v);
+        });
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param fun An operation that accepts a cache entry and processes it.
+     * @param <K> Cache key object type.
+     * @param <V> Cache value object type.
+     */
+    public static <K, V> void foreach(String cacheName, IgniteConsumer<CacheEntry<K, V>> fun) {
+        bcast(cacheName, () -> {
+            Ignite ignite = Ignition.localIgnite();
+            IgniteCache<K, V> cache = ignite.getOrCreateCache(cacheName);
+
+            int partsCnt = ignite.affinity(cacheName).partitions();
+
+            // Use affinity in filter for scan query. Otherwise we accept consumer in each node which is wrong.
+            Affinity affinity = ignite.affinity(cacheName);
+            ClusterNode locNode = ignite.cluster().localNode();
+
+            // Iterate over all partitions. Some of them will be stored on that local node.
+            for (int part = 0; part < partsCnt; part++) {
+                int p = part;
+
+                // Iterate over given partition.
+                // Query returns an empty cursor if this partition is not stored on this node.
+                for (Cache.Entry<K, V> entry : cache.query(new ScanQuery<K, V>(part,
+                    (k, v) -> affinity.mapPartitionToNode(p) == locNode)))
+                    fun.accept(new CacheEntry<>(entry, cache));
+            }
+        });
+    }
+
+    /**
+     * <b>Currently fold supports only commutative operations.<b/>
+     *
+     * @param cacheName Cache name.
+     * @param folder Fold function operating over cache entries.
+     * @param <K> Cache key object type.
+     * @param <V> Cache value object type.
+     * @param <A> Fold result type.
+     * @return Fold operation result.
+     */
+    public static <K, V, A> Collection<A> fold(String cacheName, IgniteBiFunction<CacheEntry<K, V>, A, A> folder) {
+        return bcast(cacheName, () -> {
+            Ignite ignite = Ignition.localIgnite();
+            IgniteCache<K, V> cache = ignite.getOrCreateCache(cacheName);
+
+            int partsCnt = ignite.affinity(cacheName).partitions();
+
+            // Use affinity in filter for ScanQuery. Otherwise we accept consumer in each node which is wrong.
+            Affinity affinity = ignite.affinity(cacheName);
+            ClusterNode locNode = ignite.cluster().localNode();
+
+            A a = null;
+
+            // Iterate over all partitions. Some of them will be stored on that local node.
+            for (int part = 0; part < partsCnt; part++) {
+                int p = part;
+
+                // Iterate over given partition.
+                // Query returns an empty cursor if this partition is not stored on this node.
+                for (Cache.Entry<K, V> entry : cache.query(new ScanQuery<K, V>(part,
+                    (k, v) -> affinity.mapPartitionToNode(p) == locNode)))
+                    a = folder.apply(new CacheEntry<>(entry, cache), a);
+            }
+
+            return a;
+        });
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param run {@link Runnable} to broadcast to cache nodes for given cache name.
+     */
+    public static void bcast(String cacheName, IgniteRunnable run) {
+        ignite().compute(ignite().cluster().forCacheNodes(cacheName)).broadcast(run);
+    }
+
+    /**
+     * @param cacheName Cache name.
+     * @param call {@link IgniteCallable} to broadcast to cache nodes for given cache name.
+     * @param <A> Type returned by the callable.
+     */
+    public static <A> Collection<A> bcast(String cacheName, IgniteCallable<A> call) {
+        return ignite().compute(ignite().cluster().forCacheNodes(cacheName)).broadcast(call);
+    }
+}


Mime
View raw message