ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [18/43] ignite git commit: IGNITE-5000 Rename Ignite Math module to Ignite ML module added missed licenses renamed packages fixed wrong ml profile activation
Date Wed, 19 Apr 2017 08:16:01 GMT
http://git-wip-us.apache.org/repos/asf/ignite/blob/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/DecompositionSupport.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/DecompositionSupport.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/DecompositionSupport.java
new file mode 100644
index 0000000..20d6e79
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/DecompositionSupport.java
@@ -0,0 +1,105 @@
+/*
+ * 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.ml.math.decompositions;
+
+import org.apache.ignite.ml.math.Destroyable;
+import org.apache.ignite.ml.math.Matrix;
+import org.apache.ignite.ml.math.Vector;
+import org.apache.ignite.ml.math.impls.matrix.CacheMatrix;
+import org.apache.ignite.ml.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.ml.math.impls.matrix.PivotedMatrixView;
+import org.apache.ignite.ml.math.impls.matrix.RandomMatrix;
+import org.apache.ignite.ml.math.impls.vector.DenseLocalOnHeapVector;
+
+/**
+ * Helper methods to support decomposition of matrix types having some functionality limited.
+ */
+public abstract class DecompositionSupport implements Destroyable {
+    /**
+     * Create the like matrix with read-only matrices support.
+     *
+     * @param matrix Matrix for like.
+     * @return Like matrix.
+     */
+    protected Matrix like(Matrix matrix) {
+        if (isCopyLikeSupport(matrix))
+            return new DenseLocalOnHeapMatrix(matrix.rowSize(), matrix.columnSize());
+        else
+            return matrix.like(matrix.rowSize(), matrix.columnSize());
+    }
+
+    /**
+     * Create the like matrix with specified size with read-only matrices support.
+     *
+     * @param matrix Matrix for like.
+     * @return Like matrix.
+     */
+    protected Matrix like(Matrix matrix, int rows, int cols) {
+        if (isCopyLikeSupport(matrix))
+            return new DenseLocalOnHeapMatrix(rows, cols);
+        else
+            return matrix.like(rows, cols);
+    }
+
+    /**
+     * Create the like vector with read-only matrices support.
+     *
+     * @param matrix Matrix for like.
+     * @param crd Cardinality of the vector.
+     * @return Like vector.
+     */
+    protected Vector likeVector(Matrix matrix, int crd) {
+        if (isCopyLikeSupport(matrix))
+            return new DenseLocalOnHeapVector(crd);
+        else
+            return matrix.likeVector(crd);
+    }
+
+    /**
+     * Create the like vector with read-only matrices support.
+     *
+     * @param matrix Matrix for like.
+     * @return Like vector.
+     */
+    protected Vector likeVector(Matrix matrix) {
+        return likeVector(matrix, matrix.rowSize());
+    }
+
+    /**
+     * Create the copy of matrix with read-only matrices support.
+     *
+     * @param matrix Matrix for copy.
+     * @return Copy.
+     */
+    protected Matrix copy(Matrix matrix) {
+        if (isCopyLikeSupport(matrix)) {
+            DenseLocalOnHeapMatrix cp = new DenseLocalOnHeapMatrix(matrix.rowSize(), matrix.columnSize());
+
+            cp.assign(matrix);
+
+            return cp;
+        }
+        else
+            return matrix.copy();
+    }
+
+    /** */
+    private boolean isCopyLikeSupport(Matrix matrix) {
+        return matrix instanceof RandomMatrix || matrix instanceof PivotedMatrixView || matrix instanceof CacheMatrix;
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/EigenDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/EigenDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/EigenDecomposition.java
new file mode 100644
index 0000000..01af989
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/EigenDecomposition.java
@@ -0,0 +1,923 @@
+/*
+ * 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.ml.math.decompositions;
+
+import org.apache.ignite.ml.math.Matrix;
+import org.apache.ignite.ml.math.Vector;
+import org.apache.ignite.ml.math.functions.Functions;
+
+/**
+ * This class provides EigenDecomposition of given matrix. The class is based on
+ * class with similar name from <a href="http://mahout.apache.org/">Apache Mahout</a> library.
+ *
+ * @see <a href=http://mathworld.wolfram.com/EigenDecomposition.html>MathWorld</a>
+ */
+public class EigenDecomposition extends DecompositionSupport {
+    /** Row and column dimension (square matrix). */
+    private final int n;
+
+    /** Array for internal storage of eigen vectors. */
+    private final Matrix v;
+
+    /** Array for internal storage of eigenvalues. */
+    private final Vector d;
+    /** Array for internal storage of eigenvalues. */
+    private final Vector e;
+
+    /** */
+    public EigenDecomposition(Matrix matrix) {
+        this(matrix, isSymmetric(matrix));
+    }
+
+    /** */
+    public EigenDecomposition(Matrix matrix, boolean isSymmetric) {
+        n = matrix.columnSize();
+
+        d = likeVector(matrix);
+        e = likeVector(matrix);
+        v = like(matrix);
+
+        if (isSymmetric) {
+            v.assign(matrix);
+
+            // Tridiagonalize.
+            tred2();
+
+            // Diagonalize.
+            tql2();
+
+        }
+        else
+            // Reduce to Hessenberg form.
+            // Reduce Hessenberg to real Schur form.
+            hqr2(orthes(matrix));
+    }
+
+    /**
+     * Return the eigen vector matrix
+     *
+     * @return V
+     */
+    public Matrix getV() {
+        return like(v).assign(v);
+    }
+
+    /**
+     * Return the real parts of the eigenvalues
+     */
+    public Vector getRealEigenValues() {
+        return d;
+    }
+
+    /**
+     * Return the imaginary parts of the eigenvalues
+     */
+    public Vector getImagEigenvalues() {
+        return e;
+    }
+
+    /**
+     * Return the block diagonal eigenvalue matrix
+     *
+     * @return D
+     */
+    public Matrix getD() {
+        Matrix res = like(v, d.size(), d.size());
+        res.assign(0);
+        res.viewDiagonal().assign(d);
+        for (int i = 0; i < n; i++) {
+            double v = e.getX(i);
+            if (v > 0)
+                res.setX(i, i + 1, v);
+            else if (v < 0)
+                res.setX(i, i - 1, v);
+        }
+        return res;
+    }
+
+    /**
+     * Destroys decomposition components and other internal components of decomposition.
+     */
+    @Override public void destroy() {
+        e.destroy();
+        v.destroy();
+        d.destroy();
+    }
+
+    /** */
+    private void tred2() {
+        //  This is derived from the Algol procedures tred2 by
+        //  Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+        //  Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
+        //  Fortran subroutine in EISPACK.
+
+        d.assign(v.viewColumn(n - 1));
+
+        // Householder reduction to tridiagonal form.
+
+        for (int i = n - 1; i > 0; i--) {
+
+            // Scale to avoid under/overflow.
+            double scale = d.viewPart(0, i).kNorm(1);
+            double h = 0.0;
+
+            if (scale == 0.0) {
+                e.setX(i, d.getX(i - 1));
+                for (int j = 0; j < i; j++) {
+                    d.setX(j, v.getX(i - 1, j));
+                    v.setX(i, j, 0.0);
+                    v.setX(j, i, 0.0);
+                }
+            }
+            else {
+
+                // Generate Householder vector.
+
+                for (int k = 0; k < i; k++) {
+                    d.setX(k, d.getX(k) / scale);
+                    h += d.getX(k) * d.getX(k);
+                }
+
+                double f = d.getX(i - 1);
+                double g = Math.sqrt(h);
+
+                if (f > 0)
+                    g = -g;
+
+                e.setX(i, scale * g);
+                h -= f * g;
+                d.setX(i - 1, f - g);
+
+                for (int j = 0; j < i; j++)
+                    e.setX(j, 0.0);
+
+                // Apply similarity transformation to remaining columns.
+
+                for (int j = 0; j < i; j++) {
+                    f = d.getX(j);
+                    v.setX(j, i, f);
+                    g = e.getX(j) + v.getX(j, j) * f;
+
+                    for (int k = j + 1; k <= i - 1; k++) {
+                        g += v.getX(k, j) * d.getX(k);
+                        e.setX(k, e.getX(k) + v.getX(k, j) * f);
+                    }
+
+                    e.setX(j, g);
+                }
+
+                f = 0.0;
+
+                for (int j = 0; j < i; j++) {
+                    e.setX(j, e.getX(j) / h);
+                    f += e.getX(j) * d.getX(j);
+                }
+
+                double hh = f / (h + h);
+
+                for (int j = 0; j < i; j++)
+                    e.setX(j, e.getX(j) - hh * d.getX(j));
+
+                for (int j = 0; j < i; j++) {
+                    f = d.getX(j);
+                    g = e.getX(j);
+
+                    for (int k = j; k <= i - 1; k++)
+                        v.setX(k, j, v.getX(k, j) - (f * e.getX(k) + g * d.getX(k)));
+
+                    d.setX(j, v.getX(i - 1, j));
+                    v.setX(i, j, 0.0);
+                }
+            }
+
+            d.setX(i, h);
+        }
+    }
+
+    /** */
+    private Matrix orthes(Matrix matrix) {
+        // Working storage for nonsymmetric algorithm.
+        Vector ort = likeVector(matrix);
+        Matrix hessenBerg = like(matrix).assign(matrix);
+
+        //  This is derived from the Algol procedures orthes and ortran,
+        //  by Martin and Wilkinson, Handbook for Auto. Comp.,
+        //  Vol.ii-Linear Algebra, and the corresponding
+        //  Fortran subroutines in EISPACK.
+
+        int low = 0;
+        int high = n - 1;
+
+        for (int m = low + 1; m <= high - 1; m++) {
+
+            // Scale column.
+
+            Vector hCol = hessenBerg.viewColumn(m - 1).viewPart(m, high - m + 1);
+            double scale = hCol.kNorm(1);
+
+            if (scale != 0.0) {
+                // Compute Householder transformation.
+                ort.viewPart(m, high - m + 1).map(hCol, Functions.plusMult(1 / scale));
+                double h = ort.viewPart(m, high - m + 1).getLengthSquared();
+
+                double g = Math.sqrt(h);
+
+                if (ort.getX(m) > 0)
+                    g = -g;
+
+                h -= ort.getX(m) * g;
+                ort.setX(m, ort.getX(m) - g);
+
+                // Apply Householder similarity transformation
+                // H = (I-u*u'/h)*H*(I-u*u')/h)
+
+                Vector ortPiece = ort.viewPart(m, high - m + 1);
+
+                for (int j = m; j < n; j++) {
+                    double f = ortPiece.dot(hessenBerg.viewColumn(j).viewPart(m, high - m + 1)) / h;
+                    hessenBerg.viewColumn(j).viewPart(m, high - m + 1).map(ortPiece, Functions.plusMult(-f));
+                }
+
+                for (int i = 0; i <= high; i++) {
+                    double f = ortPiece.dot(hessenBerg.viewRow(i).viewPart(m, high - m + 1)) / h;
+                    hessenBerg.viewRow(i).viewPart(m, high - m + 1).map(ortPiece, Functions.plusMult(-f));
+                }
+
+                ort.setX(m, scale * ort.getX(m));
+                hessenBerg.setX(m, m - 1, scale * g);
+            }
+        }
+
+        // Accumulate transformations (Algol's ortran).
+
+        v.assign(0);
+        v.viewDiagonal().assign(1);
+
+        for (int m = high - 1; m >= low + 1; m--) {
+            if (hessenBerg.getX(m, m - 1) != 0.0) {
+                ort.viewPart(m + 1, high - m).assign(hessenBerg.viewColumn(m - 1).viewPart(m + 1, high - m));
+
+                for (int j = m; j <= high; j++) {
+                    double g = ort.viewPart(m, high - m + 1).dot(v.viewColumn(j).viewPart(m, high - m + 1));
+
+                    // Double division avoids possible underflow
+                    g = g / ort.getX(m) / hessenBerg.getX(m, m - 1);
+                    v.viewColumn(j).viewPart(m, high - m + 1).map(ort.viewPart(m, high - m + 1), Functions.plusMult(g));
+                }
+            }
+        }
+
+        return hessenBerg;
+    }
+
+    /** Symmetric tridiagonal QL algorithm. */
+    private void tql2() {
+        //  This is derived from the Algol procedures tql2, by
+        //  Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+        //  Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
+        //  Fortran subroutine in EISPACK.
+
+        e.viewPart(0, n - 1).assign(e.viewPart(1, n - 1));
+        e.setX(n - 1, 0.0);
+
+        double f = 0.0;
+        double tst1 = 0.0;
+        double eps = Math.pow(2.0, -52.0);
+
+        for (int l = 0; l < n; l++) {
+            // Find small subdiagonal element.
+
+            tst1 = Math.max(tst1, Math.abs(d.getX(l)) + Math.abs(e.getX(l)));
+            int m = l;
+
+            while (m < n) {
+                if (Math.abs(e.getX(m)) <= eps * tst1)
+                    break;
+
+                m++;
+            }
+
+            // If m == l, d.getX(l) is an eigenvalue,
+            // otherwise, iterate.
+
+            if (m > l) {
+                do {
+                    // Compute implicit shift
+
+                    double g = d.getX(l);
+                    double p = (d.getX(l + 1) - g) / (2.0 * e.getX(l));
+                    double r = Math.hypot(p, 1.0);
+
+                    if (p < 0)
+                        r = -r;
+
+                    d.setX(l, e.getX(l) / (p + r));
+                    d.setX(l + 1, e.getX(l) * (p + r));
+                    double dl1 = d.getX(l + 1);
+                    double h = g - d.getX(l);
+
+                    for (int i = l + 2; i < n; i++)
+                        d.setX(i, d.getX(i) - h);
+
+                    f += h;
+
+                    // Implicit QL transformation.
+
+                    p = d.getX(m);
+                    double c = 1.0;
+                    double c2 = c;
+                    double c3 = c;
+                    double el1 = e.getX(l + 1);
+                    double s = 0.0;
+                    double s2 = 0.0;
+
+                    for (int i = m - 1; i >= l; i--) {
+                        c3 = c2;
+                        c2 = c;
+                        s2 = s;
+                        g = c * e.getX(i);
+                        h = c * p;
+                        r = Math.hypot(p, e.getX(i));
+                        e.setX(i + 1, s * r);
+                        s = e.getX(i) / r;
+                        c = p / r;
+                        p = c * d.getX(i) - s * g;
+                        d.setX(i + 1, h + s * (c * g + s * d.getX(i)));
+
+                        // Accumulate transformation.
+
+                        for (int k = 0; k < n; k++) {
+                            h = v.getX(k, i + 1);
+                            v.setX(k, i + 1, s * v.getX(k, i) + c * h);
+                            v.setX(k, i, c * v.getX(k, i) - s * h);
+                        }
+                    }
+
+                    p = -s * s2 * c3 * el1 * e.getX(l) / dl1;
+                    e.setX(l, s * p);
+                    d.setX(l, c * p);
+
+                    // Check for convergence.
+
+                }
+                while (Math.abs(e.getX(l)) > eps * tst1);
+            }
+
+            d.setX(l, d.getX(l) + f);
+            e.setX(l, 0.0);
+        }
+
+        // Sort eigenvalues and corresponding vectors.
+
+        for (int i = 0; i < n - 1; i++) {
+            int k = i;
+            double p = d.getX(i);
+
+            for (int j = i + 1; j < n; j++)
+                if (d.getX(j) > p) {
+                    k = j;
+                    p = d.getX(j);
+                }
+
+            if (k != i) {
+                d.setX(k, d.getX(i));
+                d.setX(i, p);
+
+                for (int j = 0; j < n; j++) {
+                    p = v.getX(j, i);
+                    v.setX(j, i, v.getX(j, k));
+                    v.setX(j, k, p);
+                }
+            }
+        }
+    }
+
+    /** */
+    private void hqr2(Matrix h) {
+        //  This is derived from the Algol procedure hqr2,
+        //  by Martin and Wilkinson, Handbook for Auto. Comp.,
+        //  Vol.ii-Linear Algebra, and the corresponding
+        //  Fortran subroutine in EISPACK.
+
+        // Initialize
+
+        int nn = this.n;
+        int n = nn - 1;
+        int low = 0;
+        int high = nn - 1;
+        double eps = Math.pow(2.0, -52.0);
+        double exshift = 0.0;
+        double p = 0;
+        double q = 0;
+        double r = 0;
+        double s = 0;
+        double z = 0;
+        double w;
+        double x;
+        double y;
+
+        // Store roots isolated by balanc and compute matrix norm
+
+        double norm = h.foldMap(Functions.PLUS, Functions.ABS, 0.0);
+
+        // Outer loop over eigenvalue index
+
+        int iter = 0;
+        while (n >= low) {
+            // Look for single small sub-diagonal element
+            int l = n;
+
+            while (l > low) {
+                s = Math.abs(h.getX(l - 1, l - 1)) + Math.abs(h.getX(l, l));
+
+                if (s == 0.0)
+                    s = norm;
+
+                if (Math.abs(h.getX(l, l - 1)) < eps * s)
+                    break;
+
+                l--;
+            }
+
+            // Check for convergence
+
+            if (l == n) {
+                // One root found
+                h.setX(n, n, h.getX(n, n) + exshift);
+                d.setX(n, h.getX(n, n));
+                e.setX(n, 0.0);
+                n--;
+                iter = 0;
+            }
+            else if (l == n - 1) {
+                // Two roots found
+                w = h.getX(n, n - 1) * h.getX(n - 1, n);
+                p = (h.getX(n - 1, n - 1) - h.getX(n, n)) / 2.0;
+                q = p * p + w;
+                z = Math.sqrt(Math.abs(q));
+                h.setX(n, n, h.getX(n, n) + exshift);
+                h.setX(n - 1, n - 1, h.getX(n - 1, n - 1) + exshift);
+                x = h.getX(n, n);
+
+                // Real pair
+                if (q >= 0) {
+                    if (p >= 0)
+                        z = p + z;
+                    else
+                        z = p - z;
+
+                    d.setX(n - 1, x + z);
+                    d.setX(n, d.getX(n - 1));
+
+                    if (z != 0.0)
+                        d.setX(n, x - w / z);
+
+                    e.setX(n - 1, 0.0);
+                    e.setX(n, 0.0);
+                    x = h.getX(n, n - 1);
+                    s = Math.abs(x) + Math.abs(z);
+                    p = x / s;
+                    q = z / s;
+                    r = Math.sqrt(p * p + q * q);
+                    p /= r;
+                    q /= r;
+
+                    // Row modification
+
+                    for (int j = n - 1; j < nn; j++) {
+                        z = h.getX(n - 1, j);
+                        h.setX(n - 1, j, q * z + p * h.getX(n, j));
+                        h.setX(n, j, q * h.getX(n, j) - p * z);
+                    }
+
+                    // Column modification
+
+                    for (int i = 0; i <= n; i++) {
+                        z = h.getX(i, n - 1);
+                        h.setX(i, n - 1, q * z + p * h.getX(i, n));
+                        h.setX(i, n, q * h.getX(i, n) - p * z);
+                    }
+
+                    // Accumulate transformations
+
+                    for (int i = low; i <= high; i++) {
+                        z = v.getX(i, n - 1);
+                        v.setX(i, n - 1, q * z + p * v.getX(i, n));
+                        v.setX(i, n, q * v.getX(i, n) - p * z);
+                    }
+
+                    // Complex pair
+
+                }
+                else {
+                    d.setX(n - 1, x + p);
+                    d.setX(n, x + p);
+                    e.setX(n - 1, z);
+                    e.setX(n, -z);
+                }
+
+                n -= 2;
+                iter = 0;
+
+                // No convergence yet
+
+            }
+            else {
+                // Form shift
+                x = h.getX(n, n);
+                y = 0.0;
+                w = 0.0;
+
+                if (l < n) {
+                    y = h.getX(n - 1, n - 1);
+                    w = h.getX(n, n - 1) * h.getX(n - 1, n);
+                }
+
+                // Wilkinson's original ad hoc shift
+
+                if (iter == 10) {
+                    exshift += x;
+
+                    for (int i = low; i <= n; i++)
+                        h.setX(i, i, x);
+
+                    s = Math.abs(h.getX(n, n - 1)) + Math.abs(h.getX(n - 1, n - 2));
+                    x = y = 0.75 * s;
+                    w = -0.4375 * s * s;
+                }
+
+                // MATLAB's new ad hoc shift
+
+                if (iter == 30) {
+                    s = (y - x) / 2.0;
+                    s = s * s + w;
+
+                    if (s > 0) {
+                        s = Math.sqrt(s);
+
+                        if (y < x)
+                            s = -s;
+
+                        s = x - w / ((y - x) / 2.0 + s);
+
+                        for (int i = low; i <= n; i++)
+                            h.setX(i, i, h.getX(i, i) - s);
+
+                        exshift += s;
+                        x = y = w = 0.964;
+                    }
+                }
+
+                iter++;   // (Could check iteration count here.)
+
+                // Look for two consecutive small sub-diagonal elements
+
+                int m = n - 2;
+
+                while (m >= l) {
+                    z = h.getX(m, m);
+                    r = x - z;
+                    s = y - z;
+                    p = (r * s - w) / h.getX(m + 1, m) + h.getX(m, m + 1);
+                    q = h.getX(m + 1, m + 1) - z - r - s;
+                    r = h.getX(m + 2, m + 1);
+                    s = Math.abs(p) + Math.abs(q) + Math.abs(r);
+                    p /= s;
+                    q /= s;
+                    r /= s;
+
+                    if (m == l)
+                        break;
+
+                    double hmag = Math.abs(h.getX(m - 1, m - 1)) + Math.abs(h.getX(m + 1, m + 1));
+                    double threshold = eps * Math.abs(p) * (Math.abs(z) + hmag);
+
+                    if (Math.abs(h.getX(m, m - 1)) * (Math.abs(q) + Math.abs(r)) < threshold)
+                        break;
+
+                    m--;
+                }
+
+                for (int i = m + 2; i <= n; i++) {
+                    h.setX(i, i - 2, 0.0);
+
+                    if (i > m + 2)
+                        h.setX(i, i - 3, 0.0);
+                }
+
+                // Double QR step involving rows l:n and columns m:n
+
+                for (int k = m; k <= n - 1; k++) {
+                    boolean notlast = k != n - 1;
+
+                    if (k != m) {
+                        p = h.getX(k, k - 1);
+                        q = h.getX(k + 1, k - 1);
+                        r = notlast ? h.getX(k + 2, k - 1) : 0.0;
+                        x = Math.abs(p) + Math.abs(q) + Math.abs(r);
+                        if (x != 0.0) {
+                            p /= x;
+                            q /= x;
+                            r /= x;
+                        }
+                    }
+
+                    if (x == 0.0)
+                        break;
+
+                    s = Math.sqrt(p * p + q * q + r * r);
+
+                    if (p < 0)
+                        s = -s;
+
+                    if (s != 0) {
+                        if (k != m)
+                            h.setX(k, k - 1, -s * x);
+                        else if (l != m)
+                            h.setX(k, k - 1, -h.getX(k, k - 1));
+
+                        p += s;
+                        x = p / s;
+                        y = q / s;
+                        z = r / s;
+                        q /= p;
+                        r /= p;
+
+                        // Row modification
+
+                        for (int j = k; j < nn; j++) {
+                            p = h.getX(k, j) + q * h.getX(k + 1, j);
+
+                            if (notlast) {
+                                p += r * h.getX(k + 2, j);
+                                h.setX(k + 2, j, h.getX(k + 2, j) - p * z);
+                            }
+
+                            h.setX(k, j, h.getX(k, j) - p * x);
+                            h.setX(k + 1, j, h.getX(k + 1, j) - p * y);
+                        }
+
+                        // Column modification
+
+                        for (int i = 0; i <= Math.min(n, k + 3); i++) {
+                            p = x * h.getX(i, k) + y * h.getX(i, k + 1);
+
+                            if (notlast) {
+                                p += z * h.getX(i, k + 2);
+                                h.setX(i, k + 2, h.getX(i, k + 2) - p * r);
+                            }
+
+                            h.setX(i, k, h.getX(i, k) - p);
+                            h.setX(i, k + 1, h.getX(i, k + 1) - p * q);
+                        }
+
+                        // Accumulate transformations
+
+                        for (int i = low; i <= high; i++) {
+                            p = x * v.getX(i, k) + y * v.getX(i, k + 1);
+
+                            if (notlast) {
+                                p += z * v.getX(i, k + 2);
+                                v.setX(i, k + 2, v.getX(i, k + 2) - p * r);
+                            }
+
+                            v.setX(i, k, v.getX(i, k) - p);
+                            v.setX(i, k + 1, v.getX(i, k + 1) - p * q);
+                        }
+                    }  // (s != 0)
+                }  // k loop
+            }  // check convergence
+        }  // while (n >= low)
+
+        // Back substitute to find vectors of upper triangular form
+
+        if (norm == 0.0)
+            return;
+
+        for (n = nn - 1; n >= 0; n--) {
+            p = d.getX(n);
+            q = e.getX(n);
+
+            // Real vector
+
+            double t;
+
+            if (q == 0) {
+                int l = n;
+                h.setX(n, n, 1.0);
+
+                for (int i = n - 1; i >= 0; i--) {
+                    w = h.getX(i, i) - p;
+                    r = 0.0;
+
+                    for (int j = l; j <= n; j++)
+                        r += h.getX(i, j) * h.getX(j, n);
+
+                    if (e.getX(i) < 0.0) {
+                        z = w;
+                        s = r;
+                    }
+                    else {
+                        l = i;
+
+                        if (e.getX(i) == 0.0) {
+                            if (w == 0.0)
+                                h.setX(i, n, -r / (eps * norm));
+                            else
+                                h.setX(i, n, -r / w);
+
+                            // Solve real equations
+
+                        }
+                        else {
+                            x = h.getX(i, i + 1);
+                            y = h.getX(i + 1, i);
+                            q = (d.getX(i) - p) * (d.getX(i) - p) + e.getX(i) * e.getX(i);
+                            t = (x * s - z * r) / q;
+                            h.setX(i, n, t);
+
+                            if (Math.abs(x) > Math.abs(z))
+                                h.setX(i + 1, n, (-r - w * t) / x);
+                            else
+                                h.setX(i + 1, n, (-s - y * t) / z);
+                        }
+
+                        // Overflow control
+
+                        t = Math.abs(h.getX(i, n));
+
+                        if (eps * t * t > 1) {
+                            for (int j = i; j <= n; j++)
+                                h.setX(j, n, h.getX(j, n) / t);
+                        }
+                    }
+                }
+
+                // Complex vector
+
+            }
+            else if (q < 0) {
+                int l = n - 1;
+
+                // Last vector component imaginary so matrix is triangular
+
+                if (Math.abs(h.getX(n, n - 1)) > Math.abs(h.getX(n - 1, n))) {
+                    h.setX(n - 1, n - 1, q / h.getX(n, n - 1));
+                    h.setX(n - 1, n, -(h.getX(n, n) - p) / h.getX(n, n - 1));
+                }
+                else {
+                    cdiv(0.0, -h.getX(n - 1, n), h.getX(n - 1, n - 1) - p, q);
+                    h.setX(n - 1, n - 1, cdivr);
+                    h.setX(n - 1, n, cdivi);
+                }
+
+                h.setX(n, n - 1, 0.0);
+                h.setX(n, n, 1.0);
+
+                for (int i = n - 2; i >= 0; i--) {
+                    double ra = 0.0;
+                    double sa = 0.0;
+
+                    for (int j = l; j <= n; j++) {
+                        ra += h.getX(i, j) * h.getX(j, n - 1);
+                        sa += h.getX(i, j) * h.getX(j, n);
+                    }
+
+                    w = h.getX(i, i) - p;
+
+                    if (e.getX(i) < 0.0) {
+                        z = w;
+                        r = ra;
+                        s = sa;
+                    }
+                    else {
+                        l = i;
+
+                        if (e.getX(i) == 0) {
+                            cdiv(-ra, -sa, w, q);
+                            h.setX(i, n - 1, cdivr);
+                            h.setX(i, n, cdivi);
+                        }
+                        else {
+
+                            // Solve complex equations
+
+                            x = h.getX(i, i + 1);
+                            y = h.getX(i + 1, i);
+
+                            double vr = (d.getX(i) - p) * (d.getX(i) - p) + e.getX(i) * e.getX(i) - q * q;
+                            double vi = (d.getX(i) - p) * 2.0 * q;
+
+                            if (vr == 0.0 && vi == 0.0) {
+                                double hmag = Math.abs(x) + Math.abs(y);
+                                vr = eps * norm * (Math.abs(w) + Math.abs(q) + hmag + Math.abs(z));
+                            }
+
+                            cdiv(x * r - z * ra + q * sa, x * s - z * sa - q * ra, vr, vi);
+
+                            h.setX(i, n - 1, cdivr);
+                            h.setX(i, n, cdivi);
+
+                            if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) {
+                                h.setX(i + 1, n - 1, (-ra - w * h.getX(i, n - 1) + q * h.getX(i, n)) / x);
+                                h.setX(i + 1, n, (-sa - w * h.getX(i, n) - q * h.getX(i, n - 1)) / x);
+                            }
+                            else {
+                                cdiv(-r - y * h.getX(i, n - 1), -s - y * h.getX(i, n), z, q);
+
+                                h.setX(i + 1, n - 1, cdivr);
+                                h.setX(i + 1, n, cdivi);
+                            }
+                        }
+
+                        // Overflow control
+
+                        t = Math.max(Math.abs(h.getX(i, n - 1)), Math.abs(h.getX(i, n)));
+
+                        if (eps * t * t > 1)
+                            for (int j = i; j <= n; j++) {
+                                h.setX(j, n - 1, h.getX(j, n - 1) / t);
+                                h.setX(j, n, h.getX(j, n) / t);
+                            }
+                    }
+                }
+            }
+        }
+
+        // Vectors of isolated roots
+
+        for (int i = 0; i < nn; i++)
+            if (i < low || i > high) {
+                for (int j = i; j < nn; j++)
+                    v.setX(i, j, h.getX(i, j));
+            }
+
+        // Back transformation to get eigen vectors of original matrix
+
+        for (int j = nn - 1; j >= low; j--)
+            for (int i = low; i <= high; i++) {
+                z = 0.0;
+
+                for (int k = low; k <= Math.min(j, high); k++)
+                    z += v.getX(i, k) * h.getX(k, j);
+
+                v.setX(i, j, z);
+            }
+    }
+
+    /** */
+    private static boolean isSymmetric(Matrix matrix) {
+        int cols = matrix.columnSize();
+        int rows = matrix.rowSize();
+
+        if (cols != rows)
+            return false;
+
+        for (int i = 0; i < cols; i++)
+            for (int j = 0; j < rows; j++) {
+                if (matrix.getX(i, j) != matrix.get(j, i))
+                    return false;
+            }
+
+        return true;
+    }
+
+    /** Complex scalar division - real part. */
+    private double cdivr;
+    /** Complex scalar division - imaginary part. */
+    private double cdivi;
+
+    /** */
+    private void cdiv(double xr, double xi, double yr, double yi) {
+        double r;
+        double d;
+
+        if (Math.abs(yr) > Math.abs(yi)) {
+            r = yi / yr;
+            d = yr + r * yi;
+            cdivr = (xr + r * xi) / d;
+            cdivi = (xi - r * xr) / d;
+        }
+        else {
+            r = yr / yi;
+            d = yi + r * yr;
+            cdivr = (r * xr + xi) / d;
+            cdivi = (r * xi - xr) / d;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/LUDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/LUDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/LUDecomposition.java
new file mode 100644
index 0000000..b1efc09
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.math.decompositions;
+
+import org.apache.ignite.ml.math.Matrix;
+import org.apache.ignite.ml.math.Vector;
+import org.apache.ignite.ml.math.exceptions.CardinalityException;
+import org.apache.ignite.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/QRDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/QRDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/QRDecomposition.java
new file mode 100644
index 0000000..39215e8
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.math.decompositions;
+
+import org.apache.ignite.ml.math.Matrix;
+import org.apache.ignite.ml.math.Vector;
+import org.apache.ignite.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/SingularValueDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/SingularValueDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/SingularValueDecomposition.java
new file mode 100644
index 0000000..1b04e4f
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.math.decompositions;
+
+import org.apache.ignite.ml.math.Algebra;
+import org.apache.ignite.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/package-info.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/decompositions/package-info.java
new file mode 100644
index 0000000..d317ccd
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.math.decompositions;

http://git-wip-us.apache.org/repos/asf/ignite/blob/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/CardinalityException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/CardinalityException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/CardinalityException.java
new file mode 100644
index 0000000..f03e5d8
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/ColumnIndexException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/ColumnIndexException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/ColumnIndexException.java
new file mode 100644
index 0000000..08a67b5
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/IndexException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/IndexException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/IndexException.java
new file mode 100644
index 0000000..93ca11e
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonPositiveDefiniteMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonPositiveDefiniteMatrixException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonPositiveDefiniteMatrixException.java
new file mode 100644
index 0000000..b0cf294
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonPositiveDefiniteMatrixException.java
@@ -0,0 +1,37 @@
+/*
+ * 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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonSymmetricMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonSymmetricMatrixException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonSymmetricMatrixException.java
new file mode 100644
index 0000000..7c563fe
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/NonSymmetricMatrixException.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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/RowIndexException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/RowIndexException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/RowIndexException.java
new file mode 100644
index 0000000..ebbbca3
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/SingularMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/SingularMatrixException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/SingularMatrixException.java
new file mode 100644
index 0000000..789b686
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.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/d78e071a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/UnknownProviderException.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/UnknownProviderException.java b/modules/ml/src/main/java/org/apache/ignite/ml/math/exceptions/UnknownProviderException.java
new file mode 100644
index 0000000..940b9aa
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/ml/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.ml.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);
+    }
+}


Mime
View raw message