You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by av...@apache.org on 2017/04/17 16:01:43 UTC
[01/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Repository: ignite
Updated Branches:
refs/heads/master d95960b62 -> 732dfea91
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java
new file mode 100644
index 0000000..0e61513
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java
@@ -0,0 +1,860 @@
+/*
+ * 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.vector;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.apache.ignite.IgniteException;
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/** See also: {@link AbstractVectorTest} and {@link VectorToMatrixTest}. */
+public class VectorImplementationsTest { // todo split this to smaller cohesive test classes
+ /** */
+ @Test
+ public void vectorImplementationsFixturesTest() {
+ new VectorImplementationsFixtures().selfTest();
+ }
+
+ /** */
+ @Test
+ public void setGetTest() {
+ consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
+ vec.set(idx, val);
+
+ return val;
+ }));
+ }
+
+ /** */
+ @Test
+ public void setXTest() {
+ consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
+ vec.setX(idx, val);
+
+ return val;
+ }));
+ }
+
+ /** */
+ @Test
+ public void incrementTest() {
+ consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
+ double old = vec.get(idx);
+
+ vec.increment(idx, val);
+
+ return old + val;
+ }));
+ }
+
+ /** */
+ @Test
+ public void incrementXTest() {
+ consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
+ double old = vec.getX(idx);
+
+ vec.incrementX(idx, val);
+
+ return old + val;
+ }));
+ }
+
+ /** */
+ @Test
+ public void operateXOutOfBoundsTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (v instanceof DenseLocalOffHeapVector || v instanceof SparseLocalVector || v instanceof SparseLocalOffHeapVector)
+ return; // todo find out if it's OK to skip by instances here
+
+ boolean expECaught = false;
+
+ try {
+ v.getX(-1);
+ }
+ catch (ArrayIndexOutOfBoundsException | IgniteException e) {
+ expECaught = true;
+ }
+
+ if (!getXOutOfBoundsOK(v))
+ assertTrue("Expect exception at negative index getX in " + desc, expECaught);
+
+ expECaught = false;
+
+ try {
+ v.setX(-1, 0);
+ }
+ catch (ArrayIndexOutOfBoundsException | IgniteException e) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at negative index setX in " + desc, expECaught);
+
+ expECaught = false;
+
+ try {
+ v.incrementX(-1, 1);
+ }
+ catch (ArrayIndexOutOfBoundsException | IgniteException e) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at negative index incrementX in " + desc, expECaught);
+
+ expECaught = false;
+
+ try {
+ v.getX(v.size());
+ }
+ catch (ArrayIndexOutOfBoundsException | IgniteException e) {
+ expECaught = true;
+ }
+
+ if (!getXOutOfBoundsOK(v))
+ assertTrue("Expect exception at too large index getX in " + desc, expECaught);
+
+ expECaught = false;
+
+ try {
+ v.setX(v.size(), 1);
+ }
+ catch (ArrayIndexOutOfBoundsException | IgniteException e) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too large index setX in " + desc, expECaught);
+
+ expECaught = false;
+
+ try {
+ v.incrementX(v.size(), 1);
+ }
+ catch (ArrayIndexOutOfBoundsException | IgniteException e) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too large index incrementX in " + desc, expECaught);
+ });
+ }
+
+ /** */
+ @Test
+ public void sizeTest() {
+ final AtomicReference<Integer> expSize = new AtomicReference<>(0);
+
+ consumeSampleVectors(
+ expSize::set,
+ (v, desc) -> assertEquals("Expected size for " + desc,
+ (int)expSize.get(), v.size())
+ );
+ }
+
+ /** */
+ @Test
+ public void getElementTest() {
+ consumeSampleVectors((v, desc) -> new ElementsChecker(v, desc).assertCloseEnough(v));
+ }
+
+ /** */
+ @Test
+ public void copyTest() {
+ consumeSampleVectors((v, desc) -> new ElementsChecker(v, desc).assertCloseEnough(v.copy()));
+ }
+
+ /** */
+ @Test
+ public void divideTest() {
+ operationTest((val, operand) -> val / operand, Vector::divide);
+ }
+
+ /** */
+ @Test
+ public void likeTest() {
+ for (int card : new int[] {1, 2, 4, 8, 16, 32, 64, 128})
+ consumeSampleVectors((v, desc) -> {
+ Class<? extends Vector> expType = expLikeType(v);
+
+ if (expType == null) {
+ try {
+ v.like(card);
+ }
+ catch (UnsupportedOperationException uoe) {
+ return;
+ }
+
+ fail("Expected exception wasn't caught for " + desc);
+
+ return;
+ }
+
+ Vector vLike = v.like(card);
+
+ assertNotNull("Expect non-null like vector for " + expType.getSimpleName() + " in " + desc, vLike);
+ assertEquals("Expect size equal to cardinality at " + desc, card, vLike.size());
+
+ Class<? extends Vector> actualType = vLike.getClass();
+
+ assertTrue("Actual vector type " + actualType.getSimpleName()
+ + " should be assignable from expected type " + expType.getSimpleName() + " in " + desc,
+ actualType.isAssignableFrom(expType));
+ });
+ }
+
+ /** */
+ @Test
+ public void minusTest() {
+ operationVectorTest((operand1, operand2) -> operand1 - operand2, Vector::minus);
+ }
+
+ /** */
+ @Test
+ public void plusVectorTest() {
+ operationVectorTest((operand1, operand2) -> operand1 + operand2, Vector::plus);
+ }
+
+ /** */
+ @Test
+ public void plusDoubleTest() {
+ operationTest((val, operand) -> val + operand, Vector::plus);
+ }
+
+ /** */
+ @Test
+ public void timesVectorTest() {
+ operationVectorTest((operand1, operand2) -> operand1 * operand2, Vector::times);
+ }
+
+ /** */
+ @Test
+ public void timesDoubleTest() {
+ operationTest((val, operand) -> val * operand, Vector::times);
+ }
+
+ /** */
+ @Test
+ public void viewPartTest() {
+ consumeSampleVectors((v, desc) -> {
+ final int size = v.size();
+ final double[] ref = new double[size];
+ final int delta = size > 32 ? 3 : 1; // IMPL NOTE this is for faster test execution
+
+ final ElementsChecker checker = new ElementsChecker(v, ref, desc);
+
+ for (int off = 0; off < size; off += delta)
+ for (int len = 1; len < size - off; len += delta)
+ checker.assertCloseEnough(v.viewPart(off, len), Arrays.copyOfRange(ref, off, off + len));
+ });
+ }
+
+ /** */
+ @Test
+ public void sumTest() {
+ toDoubleTest(
+ ref -> Arrays.stream(ref).sum(),
+ Vector::sum);
+ }
+
+ /** */
+ @Test
+ public void minValueTest() {
+ toDoubleTest(
+ ref -> Arrays.stream(ref).min().getAsDouble(),
+ Vector::minValue);
+ }
+
+ /** */
+ @Test
+ public void maxValueTest() {
+ toDoubleTest(
+ ref -> Arrays.stream(ref).max().getAsDouble(),
+ Vector::maxValue);
+ }
+
+ /** */
+ @Test
+ public void sortTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (readOnly(v) || !v.isArrayBased()) {
+ boolean expECaught = false;
+
+ try {
+ v.sort();
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception was not caught for sort in " + desc, expECaught);
+
+ return;
+ }
+
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ new ElementsChecker(v, ref, desc).assertCloseEnough(v.sort(), Arrays.stream(ref).sorted().toArray());
+ });
+ }
+
+ /** */
+ @Test
+ public void metaAttributesTest() {
+ consumeSampleVectors((v, desc) -> {
+ assertNotNull("Null meta storage in " + desc, v.getMetaStorage());
+
+ final String key = "test key";
+ final String val = "test value";
+ final String details = "key [" + key + "] for " + desc;
+
+ v.setAttribute(key, val);
+ assertTrue("Expect to have meta attribute for " + details, v.hasAttribute(key));
+ assertEquals("Unexpected meta attribute value for " + details, val, v.getAttribute(key));
+
+ v.removeAttribute(key);
+ assertFalse("Expect not to have meta attribute for " + details, v.hasAttribute(key));
+ assertNull("Unexpected meta attribute value for " + details, v.getAttribute(key));
+ });
+ }
+
+ /** */
+ @Test
+ public void assignDoubleTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (readOnly(v))
+ return;
+
+ for (double val : new double[] {0, -1, 0, 1}) {
+ v.assign(val);
+
+ for (int idx = 0; idx < v.size(); idx++) {
+ final Metric metric = new Metric(val, v.get(idx));
+
+ assertTrue("Not close enough at index " + idx + ", val " + val + ", " + metric
+ + ", " + desc, metric.closeEnough());
+ }
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void assignDoubleArrTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (readOnly(v))
+ return;
+
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ final ElementsChecker checker = new ElementsChecker(v, ref, desc);
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = -ref[idx];
+
+ v.assign(ref);
+
+ checker.assertCloseEnough(v, ref);
+
+ assignDoubleArrWrongCardinality(v, desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void assignVectorTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (readOnly(v))
+ return;
+
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ final ElementsChecker checker = new ElementsChecker(v, ref, desc);
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = -ref[idx];
+
+ v.assign(new DenseLocalOnHeapVector(ref));
+
+ checker.assertCloseEnough(v, ref);
+
+ assignVectorWrongCardinality(v, desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void assignFunctionTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (readOnly(v))
+ return;
+
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ final ElementsChecker checker = new ElementsChecker(v, ref, desc);
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = -ref[idx];
+
+ v.assign((idx) -> ref[idx]);
+
+ checker.assertCloseEnough(v, ref);
+ });
+ }
+
+ /** */
+ @Test
+ public void minElementTest() {
+ consumeSampleVectors((v, desc) -> {
+ final ElementsChecker checker = new ElementsChecker(v, desc);
+
+ final Vector.Element minE = v.minElement();
+
+ final int minEIdx = minE.index();
+
+ assertTrue("Unexpected index from minElement " + minEIdx + ", " + desc,
+ minEIdx >= 0 && minEIdx < v.size());
+
+ final Metric metric = new Metric(minE.get(), v.minValue());
+
+ assertTrue("Not close enough minElement at index " + minEIdx + ", " + metric
+ + ", " + desc, metric.closeEnough());
+
+ checker.assertNewMinElement(v);
+ });
+ }
+
+ /** */
+ @Test
+ public void maxElementTest() {
+ consumeSampleVectors((v, desc) -> {
+ final ElementsChecker checker = new ElementsChecker(v, desc);
+
+ final Vector.Element maxE = v.maxElement();
+
+ final int minEIdx = maxE.index();
+
+ assertTrue("Unexpected index from minElement " + minEIdx + ", " + desc,
+ minEIdx >= 0 && minEIdx < v.size());
+
+ final Metric metric = new Metric(maxE.get(), v.maxValue());
+
+ assertTrue("Not close enough maxElement at index " + minEIdx + ", " + metric
+ + ", " + desc, metric.closeEnough());
+
+ checker.assertNewMaxElement(v);
+ });
+ }
+
+ /** */
+ @Test
+ public void externalizeTest() {
+ (new ExternalizeTest<Vector>() {
+ /** {@inheritDoc} */
+ @Override public void externalizeTest() {
+ consumeSampleVectors((v, desc) -> {
+ if (v instanceof SparseLocalOffHeapVector)
+ return; //TODO: wait till SparseLocalOffHeapVector externalization support.
+
+ externalizeTest(v);
+ });
+ }
+ }).externalizeTest();
+ }
+
+ /** */
+ @Test
+ public void hashCodeTest() {
+ consumeSampleVectors((v, desc) -> assertTrue("Zero hash code for " + desc, v.hashCode() != 0));
+ }
+
+ /** */
+ private boolean getXOutOfBoundsOK(Vector v) {
+ // todo find out if this is indeed OK
+ return v instanceof RandomVector || v instanceof ConstantVector
+ || v instanceof SingleElementVector || v instanceof SingleElementVectorView;
+ }
+
+ /** */
+ private void mutateAtIdxTest(Vector v, String desc, MutateAtIdx operation) {
+ if (readOnly(v)) {
+ if (v.size() < 1)
+ return;
+
+ boolean expECaught = false;
+
+ try {
+ operation.apply(v, 0, 1);
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at attempt to mutate element in " + desc, expECaught);
+
+ return;
+ }
+
+ for (double val : new double[] {0, -1, 0, 1})
+ for (int idx = 0; idx < v.size(); idx++) {
+ double exp = operation.apply(v, idx, val);
+
+ final Metric metric = new Metric(exp, v.get(idx));
+
+ assertTrue("Not close enough at index " + idx + ", val " + val + ", " + metric
+ + ", " + desc, metric.closeEnough());
+ }
+ }
+
+ /** */
+ private Class<? extends Vector> expLikeType(Vector v) {
+ Class<? extends Vector> clazz = v.getClass();
+
+ if (clazz.isAssignableFrom(PivotedVectorView.class) || clazz.isAssignableFrom(SingleElementVectorView.class))
+ return null;
+
+ if (clazz.isAssignableFrom(MatrixVectorView.class) || clazz.isAssignableFrom(DelegatingVector.class))
+ return DenseLocalOnHeapVector.class; // IMPL NOTE per fixture
+
+ return clazz;
+ }
+
+ /** */
+ private void toDoubleTest(Function<double[], Double> calcRef, Function<Vector, Double> calcVec) {
+ consumeSampleVectors((v, desc) -> {
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ new ElementsChecker(v, ref, desc); // IMPL NOTE this initialises vector and reference array
+
+ final Metric metric = new Metric(calcRef.apply(ref), calcVec.apply(v));
+
+ assertTrue("Not close enough at " + desc
+ + ", " + metric, metric.closeEnough());
+ });
+ }
+
+ /** */
+ private void operationVectorTest(BiFunction<Double, Double, Double> operation,
+ BiFunction<Vector, Vector, Vector> vecOperation) {
+ consumeSampleVectors((v, desc) -> {
+ // TODO find out if more elaborate testing scenario is needed or it's okay as is.
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ final ElementsChecker checker = new ElementsChecker(v, ref, desc);
+ final Vector operand = v.copy();
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = operation.apply(ref[idx], ref[idx]);
+
+ checker.assertCloseEnough(vecOperation.apply(v, operand), ref);
+
+ assertWrongCardinality(v, desc, vecOperation);
+ });
+ }
+
+ /** */
+ private void assignDoubleArrWrongCardinality(Vector v, String desc) {
+ boolean expECaught = false;
+
+ try {
+ v.assign(new double[v.size() + 1]);
+ }
+ catch (CardinalityException ce) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too large size in " + desc, expECaught);
+
+ if (v.size() < 2)
+ return;
+
+ expECaught = false;
+
+ try {
+ v.assign(new double[v.size() - 1]);
+ }
+ catch (CardinalityException ce) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too small size in " + desc, expECaught);
+ }
+
+ /** */
+ private void assignVectorWrongCardinality(Vector v, String desc) {
+ boolean expECaught = false;
+
+ try {
+ v.assign(new DenseLocalOnHeapVector(v.size() + 1));
+ }
+ catch (CardinalityException ce) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too large size in " + desc, expECaught);
+
+ if (v.size() < 2)
+ return;
+
+ expECaught = false;
+
+ try {
+ v.assign(new DenseLocalOnHeapVector(v.size() - 1));
+ }
+ catch (CardinalityException ce) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too small size in " + desc, expECaught);
+ }
+
+ /** */
+ private void assertWrongCardinality(
+ Vector v, String desc, BiFunction<Vector, Vector, Vector> vecOperation) {
+ boolean expECaught = false;
+
+ try {
+ vecOperation.apply(v, new DenseLocalOnHeapVector(v.size() + 1));
+ }
+ catch (CardinalityException ce) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too large size in " + desc, expECaught);
+
+ if (v.size() < 2)
+ return;
+
+ expECaught = false;
+
+ try {
+ vecOperation.apply(v, new DenseLocalOnHeapVector(v.size() - 1));
+ }
+ catch (CardinalityException ce) {
+ expECaught = true;
+ }
+
+ assertTrue("Expect exception at too small size in " + desc, expECaught);
+ }
+
+ /** */
+ private void operationTest(BiFunction<Double, Double, Double> operation,
+ BiFunction<Vector, Double, Vector> vecOperation) {
+ for (double val : new double[] {0, 0.1, 1, 2, 10})
+ consumeSampleVectors((v, desc) -> {
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ final ElementsChecker checker = new ElementsChecker(v, ref, "val " + val + ", " + desc);
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = operation.apply(ref[idx], val);
+
+ checker.assertCloseEnough(vecOperation.apply(v, val), ref);
+ });
+ }
+
+ /** */
+ private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
+ consumeSampleVectors(null, consumer);
+ }
+
+ /** */
+ private void consumeSampleVectors(Consumer<Integer> paramsConsumer, BiConsumer<Vector, String> consumer) {
+ new VectorImplementationsFixtures().consumeSampleVectors(paramsConsumer, consumer);
+ }
+
+ /** */
+ private static boolean readOnly(Vector v) {
+ return v instanceof RandomVector || v instanceof ConstantVector;
+ }
+
+ /** */
+ private interface MutateAtIdx {
+ /** */
+ double apply(Vector v, int idx, double val);
+ }
+
+ /** */
+ static class ElementsChecker {
+ /** */
+ private final String fixtureDesc;
+
+ /** */
+ private final double[] refReadOnly;
+
+ /** */
+ private final boolean nonNegative;
+
+ /** */
+ ElementsChecker(Vector v, double[] ref, String fixtureDesc, boolean nonNegative) {
+ this.fixtureDesc = fixtureDesc;
+
+ this.nonNegative = nonNegative;
+
+ refReadOnly = readOnly(v) && ref == null ? new double[v.size()] : null;
+
+ init(v, ref);
+ }
+
+ /** */
+ ElementsChecker(Vector v, double[] ref, String fixtureDesc) {
+ this(v, ref, fixtureDesc, false);
+ }
+
+ /** */
+ ElementsChecker(Vector v, String fixtureDesc) {
+ this(v, null, fixtureDesc);
+ }
+
+ /** */
+ void assertCloseEnough(Vector obtained, double[] exp) {
+ final int size = obtained.size();
+
+ for (int i = 0; i < size; i++) {
+ final Vector.Element e = obtained.getElement(i);
+
+ if (refReadOnly != null && exp == null)
+ exp = refReadOnly;
+
+ final Metric metric = new Metric(exp == null ? generated(i) : exp[i], e.get());
+
+ assertEquals("Unexpected vector index at " + fixtureDesc, i, e.index());
+ assertTrue("Not close enough at index " + i + ", size " + size + ", " + metric
+ + ", " + fixtureDesc, metric.closeEnough());
+ }
+ }
+
+ /** */
+ void assertCloseEnough(Vector obtained) {
+ assertCloseEnough(obtained, null);
+ }
+
+ /** */
+ void assertNewMinElement(Vector v) {
+ if (readOnly(v))
+ return;
+
+ int exp = v.size() / 2;
+
+ v.set(exp, -(v.size() * 2 + 1));
+
+ assertEquals("Unexpected minElement index at " + fixtureDesc, exp, v.minElement().index());
+ }
+
+ /** */
+ void assertNewMaxElement(Vector v) {
+ if (readOnly(v))
+ return;
+
+ int exp = v.size() / 2;
+
+ v.set(exp, v.size() * 2 + 1);
+
+ assertEquals("Unexpected minElement index at " + fixtureDesc, exp, v.maxElement().index());
+ }
+
+ /** */
+ private void init(Vector v, double[] ref) {
+ if (readOnly(v)) {
+ initReadonly(v, ref);
+
+ return;
+ }
+
+ for (Vector.Element e : v.all()) {
+ int idx = e.index();
+
+ // IMPL NOTE introduce negative values because their absence
+ // blocked catching an ugly bug in AbstractVector#kNorm
+ int val = generated(idx);
+
+ e.set(val);
+
+ if (ref != null)
+ ref[idx] = val;
+ }
+ }
+
+ /** */
+ private void initReadonly(Vector v, double[] ref) {
+ if (refReadOnly != null)
+ for (Vector.Element e : v.all())
+ refReadOnly[e.index()] = e.get();
+
+ if (ref != null)
+ for (Vector.Element e : v.all())
+ ref[e.index()] = e.get();
+ }
+
+ /** */
+ private int generated(int idx) {
+ return nonNegative || (idx & 1) == 0 ? idx : -idx;
+ }
+ }
+
+ /** */
+ static class Metric { // todo consider if softer tolerance (like say 0.1 or 0.01) would make sense here
+ /** */
+ private final double exp;
+
+ /** */
+ private final double obtained;
+
+ /** **/
+ Metric(double exp, double obtained) {
+ this.exp = exp;
+ this.obtained = obtained;
+ }
+
+ /** */
+ boolean closeEnough() {
+ return new Double(exp).equals(obtained) || closeEnoughToZero();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ return "Metric{" + "expected=" + exp +
+ ", obtained=" + obtained +
+ '}';
+ }
+
+ /** */
+ private boolean closeEnoughToZero() {
+ return (new Double(exp).equals(0.0) && new Double(obtained).equals(-0.0))
+ || (new Double(exp).equals(-0.0) && new Double(obtained).equals(0.0));
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java
new file mode 100644
index 0000000..7a64c85
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java
@@ -0,0 +1,376 @@
+/*
+ * 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.vector;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Spliterator;
+import java.util.function.BiConsumer;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Test;
+
+import static java.util.Spliterator.ORDERED;
+import static java.util.Spliterator.SIZED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/** */
+public class VectorIterableTest {
+ /** */
+ @Test
+ public void allTest() {
+ consumeSampleVectors(
+ (v, desc) -> {
+ int expIdx = 0;
+
+ for (Vector.Element e : v.all()) {
+ int actualIdx = e.index();
+
+ assertEquals("Unexpected index for " + desc,
+ expIdx, actualIdx);
+
+ expIdx++;
+ }
+
+ assertEquals("Unexpected amount of elements for " + desc,
+ expIdx, v.size());
+ }
+ );
+ }
+
+ /** */
+ @Test
+ public void allTestBound() {
+ consumeSampleVectors(
+ (v, desc) -> iteratorTestBound(v.all().iterator(), desc)
+ );
+ }
+
+ /** */
+ @Test
+ public void nonZeroesTestBasic() {
+ final int size = 5;
+
+ final double[] nonZeroesOddData = new double[size], nonZeroesEvenData = new double[size];
+
+ for (int idx = 0; idx < size; idx++) {
+ final boolean odd = (idx & 1) == 1;
+
+ nonZeroesOddData[idx] = odd ? 1 : 0;
+
+ nonZeroesEvenData[idx] = odd ? 0 : 1;
+ }
+
+ assertTrue("Arrays failed to initialize.",
+ !isZero(nonZeroesEvenData[0])
+ && isZero(nonZeroesEvenData[1])
+ && isZero(nonZeroesOddData[0])
+ && !isZero(nonZeroesOddData[1]));
+
+ final Vector nonZeroesEvenVec = new DenseLocalOnHeapVector(nonZeroesEvenData),
+ nonZeroesOddVec = new DenseLocalOnHeapVector(nonZeroesOddData);
+
+ assertTrue("Vectors failed to initialize.",
+ !isZero(nonZeroesEvenVec.getElement(0).get())
+ && isZero(nonZeroesEvenVec.getElement(1).get())
+ && isZero(nonZeroesOddVec.getElement(0).get())
+ && !isZero(nonZeroesOddVec.getElement(1).get()));
+
+ assertTrue("Iterator(s) failed to start.",
+ nonZeroesEvenVec.nonZeroes().iterator().next() != null
+ && nonZeroesOddVec.nonZeroes().iterator().next() != null);
+
+ int nonZeroesActual = 0;
+
+ for (Vector.Element e : nonZeroesEvenVec.nonZeroes()) {
+ final int idx = e.index();
+
+ final boolean odd = (idx & 1) == 1;
+
+ final double val = e.get();
+
+ assertTrue("Not an even index " + idx + ", for value " + val, !odd);
+
+ assertTrue("Zero value " + val + " at even index " + idx, !isZero(val));
+
+ nonZeroesActual++;
+ }
+
+ final int nonZeroesOddExp = (size + 1) / 2;
+
+ assertEquals("Unexpected num of iterated odd non-zeroes.", nonZeroesOddExp, nonZeroesActual);
+
+ assertEquals("Unexpected nonZeroElements of odd.", nonZeroesOddExp, nonZeroesEvenVec.nonZeroElements());
+
+ nonZeroesActual = 0;
+
+ for (Vector.Element e : nonZeroesOddVec.nonZeroes()) {
+ final int idx = e.index();
+
+ final boolean odd = (idx & 1) == 1;
+
+ final double val = e.get();
+
+ assertTrue("Not an odd index " + idx + ", for value " + val, odd);
+
+ assertTrue("Zero value " + val + " at even index " + idx, !isZero(val));
+
+ nonZeroesActual++;
+ }
+
+ final int nonZeroesEvenExp = size / 2;
+
+ assertEquals("Unexpected num of iterated even non-zeroes", nonZeroesEvenExp, nonZeroesActual);
+
+ assertEquals("Unexpected nonZeroElements of even", nonZeroesEvenExp, nonZeroesOddVec.nonZeroElements());
+ }
+
+ /** */
+ @Test
+ public void nonZeroesTest() {
+ // todo make RandomVector constructor that accepts a function and use it here
+ // in order to *reliably* test non-zeroes in there
+ consumeSampleVectors(
+ (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
+ -> {
+ int numZeroesActual = vec.size();
+
+ for (Vector.Element e : vec.nonZeroes()) {
+ numZeroesActual--;
+
+ assertTrue("Unexpected zero at " + desc + ", index " + e.index(), !isZero(e.get()));
+ }
+
+ assertEquals("Unexpected num zeroes at " + desc, (int)numZeroes, numZeroesActual);
+ }));
+ }
+
+ /** */
+ @Test
+ public void nonZeroesTestBound() {
+ consumeSampleVectors(
+ (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
+ -> iteratorTestBound(vec.nonZeroes().iterator(), desc)));
+ }
+
+ /** */
+ @Test
+ public void nonZeroElementsTest() {
+ consumeSampleVectors(
+ (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
+ -> assertEquals("Unexpected num zeroes at " + desc,
+ (int)numZeroes, vec.size() - vec.nonZeroElements())));
+ }
+
+ /** */
+ @Test
+ public void allSpliteratorTest() {
+ consumeSampleVectors(
+ (v, desc) -> {
+ final String desc1 = " " + desc;
+
+ Spliterator<Double> spliterator = v.allSpliterator();
+
+ assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
+
+ assertNull(MathTestConstants.NOT_NULL_VAL + desc1, spliterator.trySplit());
+
+ assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
+
+ if (!readOnly(v))
+ fillWithNonZeroes(v);
+
+ spliterator = v.allSpliterator();
+
+ assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.estimateSize(), v.size());
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.getExactSizeIfKnown(), v.size());
+
+ assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
+
+ Spliterator<Double> secondHalf = spliterator.trySplit();
+
+ assertNull(MathTestConstants.NOT_NULL_VAL + desc1, secondHalf);
+
+ spliterator.tryAdvance(x -> {
+ });
+ }
+ );
+ }
+
+ /** */
+ @Test
+ public void nonZeroSpliteratorTest() {
+ consumeSampleVectors(
+ (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
+ -> {
+ final String desc1 = " Num zeroes " + numZeroes + " " + desc;
+
+ Spliterator<Double> spliterator = vec.nonZeroSpliterator();
+
+ assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
+
+ assertNull(MathTestConstants.NOT_NULL_VAL + desc1, spliterator.trySplit());
+
+ assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
+
+ spliterator = vec.nonZeroSpliterator();
+
+ assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.estimateSize(), vec.size() - numZeroes);
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.getExactSizeIfKnown(), vec.size() - numZeroes);
+
+ assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
+
+ Spliterator<Double> secondHalf = spliterator.trySplit();
+
+ assertNull(MathTestConstants.NOT_NULL_VAL + desc1, secondHalf);
+
+ double[] data = new double[vec.size()];
+
+ for (Vector.Element e : vec.all())
+ data[e.index()] = e.get();
+
+ spliterator = vec.nonZeroSpliterator();
+
+ assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.estimateSize(),
+ Arrays.stream(data).filter(x -> x != 0d).count());
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.getExactSizeIfKnown(),
+ Arrays.stream(data).filter(x -> x != 0d).count());
+
+ assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
+
+ secondHalf = spliterator.trySplit();
+
+ assertNull(MathTestConstants.NOT_NULL_VAL + desc1, secondHalf);
+
+ if (!spliterator.tryAdvance(x -> {
+ }))
+ fail(MathTestConstants.NO_NEXT_ELEMENT + desc1);
+ }));
+ }
+
+ /** */
+ private void iteratorTestBound(Iterator<Vector.Element> it, String desc) {
+ while (it.hasNext())
+ assertNotNull(it.next());
+
+ boolean expECaught = false;
+
+ try {
+ it.next();
+ }
+ catch (NoSuchElementException e) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception missed for " + desc,
+ expECaught);
+ }
+
+ /** */
+ private void consumeSampleVectorsWithZeroes(Vector sample,
+ BiConsumer<Vector, Integer> consumer) {
+ if (readOnly(sample)) {
+ int numZeroes = 0;
+
+ for (Vector.Element e : sample.all())
+ if (isZero(e.get()))
+ numZeroes++;
+
+ consumer.accept(sample, numZeroes);
+
+ return;
+ }
+
+ fillWithNonZeroes(sample);
+
+ consumer.accept(sample, 0);
+
+ final int sampleSize = sample.size();
+
+ if (sampleSize == 0)
+ return;
+
+ for (Vector.Element e : sample.all())
+ e.set(0);
+
+ consumer.accept(sample, sampleSize);
+
+ fillWithNonZeroes(sample);
+
+ for (int testIdx : new int[] {0, sampleSize / 2, sampleSize - 1}) {
+ final Vector.Element e = sample.getElement(testIdx);
+
+ final double backup = e.get();
+
+ e.set(0);
+
+ consumer.accept(sample, 1);
+
+ e.set(backup);
+ }
+
+ if (sampleSize < 3)
+ return;
+
+ sample.getElement(sampleSize / 3).set(0);
+
+ sample.getElement((2 * sampleSize) / 3).set(0);
+
+ consumer.accept(sample, 2);
+ }
+
+ /** */
+ private void fillWithNonZeroes(Vector sample) {
+ int idx = 0;
+
+ for (Vector.Element e : sample.all())
+ e.set(1 + idx++);
+
+ assertEquals("Not all filled with non-zeroes", idx, sample.size());
+ }
+
+ /** */
+ private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
+ new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
+ }
+
+ /** */
+ private boolean isZero(double val) {
+ return val == 0.0;
+ }
+
+ /** */
+ private boolean readOnly(Vector v) {
+ return v instanceof RandomVector || v instanceof ConstantVector;
+ }
+}
+
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java
new file mode 100644
index 0000000..f1c2928
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java
@@ -0,0 +1,247 @@
+/*
+ * 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.vector;
+
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import org.apache.ignite.math.Vector;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class VectorNormTest {
+ /** */
+ @Test
+ public void normalizeTest() {
+ normalizeTest(2, (val, len) -> val / len, Vector::normalize);
+ }
+
+ /** */
+ @Test
+ public void normalizePowerTest() {
+ for (double pow : new double[] {0, 0.5, 1, 2, 2.5, Double.POSITIVE_INFINITY})
+ normalizeTest(pow, (val, norm) -> val / norm, (v) -> v.normalize(pow));
+ }
+
+ /** */
+ @Test
+ public void logNormalizeTest() {
+ normalizeTest(2, (val, len) -> Math.log1p(val) / (len * Math.log(2)), Vector::logNormalize);
+ }
+
+ /** */
+ @Test
+ public void logNormalizePowerTest() {
+ for (double pow : new double[] {1.1, 2, 2.5})
+ normalizeTest(pow, (val, norm) -> Math.log1p(val) / (norm * Math.log(pow)), (v) -> v.logNormalize(pow));
+ }
+
+ /** */
+ @Test
+ public void kNormTest() {
+ for (double pow : new double[] {0, 0.5, 1, 2, 2.5, Double.POSITIVE_INFINITY})
+ toDoubleTest(pow, ref -> new Norm(ref, pow).calculate(), v -> v.kNorm(pow));
+ }
+
+ /** */
+ @Test
+ public void getLengthSquaredTest() {
+ toDoubleTest(2.0, ref -> new Norm(ref, 2).sumPowers(), Vector::getLengthSquared);
+ }
+
+ /** */
+ @Test
+ public void getDistanceSquaredTest() {
+ consumeSampleVectors((v, desc) -> {
+ new VectorImplementationsTest.ElementsChecker(v, desc); // IMPL NOTE this initialises vector
+
+ final int size = v.size();
+ final Vector vOnHeap = new DenseLocalOnHeapVector(size);
+ final Vector vOffHeap = new DenseLocalOffHeapVector(size);
+
+ invertValues(v, vOnHeap);
+ invertValues(v, vOffHeap);
+
+ for (int idx = 0; idx < size; idx++) {
+ final double exp = v.get(idx);
+ final int idxMirror = size - 1 - idx;
+
+ assertTrue("On heap vector difference at " + desc + ", idx " + idx,
+ exp - vOnHeap.get(idxMirror) == 0);
+ assertTrue("Off heap vector difference at " + desc + ", idx " + idx,
+ exp - vOffHeap.get(idxMirror) == 0);
+ }
+
+ final double exp = vOnHeap.minus(v).getLengthSquared(); // IMPL NOTE this won't mutate vOnHeap
+ final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(exp, v.getDistanceSquared(vOnHeap));
+
+ assertTrue("On heap vector not close enough at " + desc + ", " + metric,
+ metric.closeEnough());
+
+ final VectorImplementationsTest.Metric metric1 = new VectorImplementationsTest.Metric(exp, v.getDistanceSquared(vOffHeap));
+
+ assertTrue("Off heap vector not close enough at " + desc + ", " + metric1,
+ metric1.closeEnough());
+ });
+ }
+
+ /** */
+ @Test
+ public void dotTest() {
+ consumeSampleVectors((v, desc) -> {
+ new VectorImplementationsTest.ElementsChecker(v, desc); // IMPL NOTE this initialises vector
+
+ final int size = v.size();
+ final Vector v1 = new DenseLocalOnHeapVector(size);
+
+ invertValues(v, v1);
+
+ final double actual = v.dot(v1);
+
+ double exp = 0;
+
+ for (Vector.Element e : v.all())
+ exp += e.get() * v1.get(e.index());
+
+ final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(exp, actual);
+
+ assertTrue("Dot product not close enough at " + desc + ", " + metric,
+ metric.closeEnough());
+ });
+ }
+
+ /** */
+ private void invertValues(Vector src, Vector dst) {
+ final int size = src.size();
+
+ for (Vector.Element e : src.all()) {
+ final int idx = size - 1 - e.index();
+ final double val = e.get();
+
+ dst.set(idx, val);
+ }
+ }
+
+ /** */
+ private void toDoubleTest(Double val, Function<double[], Double> calcRef, Function<Vector, Double> calcVec) {
+ consumeSampleVectors((v, desc) -> {
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ new VectorImplementationsTest.ElementsChecker(v, ref, desc); // IMPL NOTE this initialises vector and reference array
+
+ final double exp = calcRef.apply(ref);
+ final double obtained = calcVec.apply(v);
+ final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(exp, obtained);
+
+ assertTrue("Not close enough at " + desc
+ + (val == null ? "" : ", value " + val) + ", " + metric, metric.closeEnough());
+ });
+ }
+
+ /** */
+ private void normalizeTest(double pow, BiFunction<Double, Double, Double> operation,
+ Function<Vector, Vector> vecOperation) {
+ consumeSampleVectors((v, desc) -> {
+ final int size = v.size();
+ final double[] ref = new double[size];
+ final boolean nonNegative = pow != (int)pow;
+
+ final VectorImplementationsTest.ElementsChecker checker = new VectorImplementationsTest.ElementsChecker(v, ref, desc + ", pow = " + pow, nonNegative);
+ final double norm = new Norm(ref, pow).calculate();
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = operation.apply(ref[idx], norm);
+
+ checker.assertCloseEnough(vecOperation.apply(v), ref);
+ });
+ }
+
+ /** */
+ private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
+ new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
+ }
+
+ /** */
+ private static class Norm {
+ /** */
+ private final double[] arr;
+
+ /** */
+ private final Double pow;
+
+ /** */
+ Norm(double[] arr, double pow) {
+ this.arr = arr;
+ this.pow = pow;
+ }
+
+ /** */
+ double calculate() {
+ if (pow.equals(0.0))
+ return countNonZeroes(); // IMPL NOTE this is beautiful if you think of it
+
+ if (pow.equals(Double.POSITIVE_INFINITY))
+ return maxAbs();
+
+ return Math.pow(sumPowers(), 1 / pow);
+ }
+
+ /** */
+ double sumPowers() {
+ if (pow.equals(0.0))
+ return countNonZeroes();
+
+ double norm = 0;
+
+ for (double val : arr)
+ norm += pow == 1 ? Math.abs(val) : Math.pow(val, pow);
+
+ return norm;
+ }
+
+ /** */
+ private int countNonZeroes() {
+ int cnt = 0;
+
+ final Double zero = 0.0;
+
+ for (double val : arr)
+ if (!zero.equals(val))
+ cnt++;
+
+ return cnt;
+ }
+
+ /** */
+ private double maxAbs() {
+ double res = 0;
+
+ for (double val : arr) {
+ final double abs = Math.abs(val);
+
+ if (abs > res)
+ res = abs;
+ }
+
+ return res;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java
new file mode 100644
index 0000000..adcb2cc
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java
@@ -0,0 +1,291 @@
+package org.apache.ignite.math.impls.vector;
+
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.matrix.RandomMatrix;
+import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrix;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/** Tests for methods of Vector that involve Matrix. */
+public class VectorToMatrixTest {
+ /** */
+ private static final Map<Class<? extends Vector>, Class<? extends Matrix>> typesMap = typesMap();
+
+ /** */
+ private static final List<Class<? extends Vector>> likeMatrixUnsupported = Arrays.asList(FunctionVector.class,
+ SingleElementVector.class, SingleElementVectorView.class, ConstantVector.class);
+
+ /** */
+ @Test
+ public void testHaveLikeMatrix() throws InstantiationException, IllegalAccessException {
+ for (Class<? extends Vector> key : typesMap.keySet()) {
+ Class<? extends Matrix> val = typesMap.get(key);
+
+ if (val == null && likeMatrixSupported(key))
+ System.out.println("Missing test for implementation of likeMatrix for " + key.getSimpleName());
+ }
+ }
+
+ /** */
+ @Test
+ public void testLikeMatrixUnsupported() throws Exception {
+ consumeSampleVectors((v, desc) -> {
+ if (likeMatrixSupported(v.getClass()))
+ return;
+
+ boolean expECaught = false;
+
+ try {
+ assertNull("Null view instead of exception in " + desc, v.likeMatrix(1, 1));
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception was not caught in " + desc, expECaught);
+ });
+ }
+
+ /** */
+ @Test
+ public void testLikeMatrix() {
+ consumeSampleVectors((v, desc) -> {
+ if (!availableForTesting(v))
+ return;
+
+ final Matrix matrix = v.likeMatrix(1, 1);
+
+ Class<? extends Vector> key = v.getClass();
+
+ Class<? extends Matrix> expMatrixType = typesMap.get(key);
+
+ assertNotNull("Expect non-null matrix for " + key.getSimpleName() + " in " + desc, matrix);
+
+ Class<? extends Matrix> actualMatrixType = matrix.getClass();
+
+ assertTrue("Expected matrix type " + expMatrixType.getSimpleName()
+ + " should be assignable from actual type " + actualMatrixType.getSimpleName() + " in " + desc,
+ expMatrixType.isAssignableFrom(actualMatrixType));
+
+ for (int rows : new int[] {1, 2})
+ for (int cols : new int[] {1, 2}) {
+ final Matrix actualMatrix = v.likeMatrix(rows, cols);
+
+ String details = "rows " + rows + " cols " + cols;
+
+ assertNotNull("Expect non-null matrix for " + details + " in " + desc,
+ actualMatrix);
+
+ assertEquals("Unexpected number of rows in " + desc, rows, actualMatrix.rowSize());
+
+ assertEquals("Unexpected number of cols in " + desc, cols, actualMatrix.columnSize());
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testToMatrix() {
+ consumeSampleVectors((v, desc) -> {
+ if (!availableForTesting(v))
+ return;
+
+ fillWithNonZeroes(v);
+
+ final Matrix matrixRow = v.toMatrix(true);
+
+ final Matrix matrixCol = v.toMatrix(false);
+
+ for (Vector.Element e : v.all())
+ assertToMatrixValue(desc, matrixRow, matrixCol, e.get(), e.index());
+ });
+ }
+
+ /** */
+ @Test
+ public void testToMatrixPlusOne() {
+ consumeSampleVectors((v, desc) -> {
+ if (!availableForTesting(v))
+ return;
+
+ fillWithNonZeroes(v);
+
+ for (double zeroVal : new double[] {-1, 0, 1, 2}) {
+ final Matrix matrixRow = v.toMatrixPlusOne(true, zeroVal);
+
+ final Matrix matrixCol = v.toMatrixPlusOne(false, zeroVal);
+
+ final Metric metricRow0 = new Metric(zeroVal, matrixRow.get(0, 0));
+
+ assertTrue("Not close enough row like " + metricRow0 + " at index 0 in " + desc,
+ metricRow0.closeEnough());
+
+ final Metric metricCol0 = new Metric(zeroVal, matrixCol.get(0, 0));
+
+ assertTrue("Not close enough cols like " + metricCol0 + " at index 0 in " + desc,
+ metricCol0.closeEnough());
+
+ for (Vector.Element e : v.all())
+ assertToMatrixValue(desc, matrixRow, matrixCol, e.get(), e.index() + 1);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testCross() {
+ consumeSampleVectors((v, desc) -> {
+ if (!availableForTesting(v))
+ return;
+
+ fillWithNonZeroes(v);
+
+ for (int delta : new int[] {-1, 0, 1}) {
+ final int size2 = v.size() + delta;
+
+ if (size2 < 1)
+ return;
+
+ final Vector v2 = new DenseLocalOnHeapVector(size2);
+
+ for (Vector.Element e : v2.all())
+ e.set(size2 - e.index());
+
+ assertCross(v, v2, desc);
+ }
+ });
+ }
+
+ /** */
+ private void assertCross(Vector v1, Vector v2, String desc) {
+ assertNotNull(v1);
+ assertNotNull(v2);
+
+ final Matrix res = v1.cross(v2);
+
+ assertNotNull("Cross matrix is expected to be not null in " + desc, res);
+
+ assertEquals("Unexpected number of rows in cross Matrix in " + desc, v1.size(), res.rowSize());
+
+ assertEquals("Unexpected number of cols in cross Matrix in " + desc, v2.size(), res.columnSize());
+
+ for (int row = 0; row < v1.size(); row++)
+ for (int col = 0; col < v2.size(); col++) {
+ final Metric metric = new Metric(v1.get(row) * v2.get(col), res.get(row, col));
+
+ assertTrue("Not close enough cross " + metric + " at row " + row + " at col " + col
+ + " in " + desc, metric.closeEnough());
+ }
+ }
+
+ /** */
+ private void assertToMatrixValue(String desc, Matrix matrixRow, Matrix matrixCol, double exp, int idx) {
+ final Metric metricRow = new Metric(exp, matrixRow.get(0, idx));
+
+ assertTrue("Not close enough row like " + metricRow + " at index " + idx + " in " + desc,
+ metricRow.closeEnough());
+
+ final Metric metricCol = new Metric(exp, matrixCol.get(idx, 0));
+
+ assertTrue("Not close enough cols like " + matrixCol + " at index " + idx + " in " + desc,
+ metricCol.closeEnough());
+ }
+
+ /** */
+ private void fillWithNonZeroes(Vector sample) {
+ if (sample instanceof RandomVector)
+ return;
+
+ for (Vector.Element e : sample.all())
+ e.set(1 + e.index());
+ }
+
+ /** */
+ private boolean availableForTesting(Vector v) {
+ assertNotNull("Error in test: vector is null", v);
+
+ if (!likeMatrixSupported(v.getClass()))
+ return false;
+
+ final boolean availableForTesting = typesMap.get(v.getClass()) != null;
+
+ final Matrix actualLikeMatrix = v.likeMatrix(1, 1);
+
+ assertTrue("Need to enable matrix testing for vector type " + v.getClass().getSimpleName(),
+ availableForTesting || actualLikeMatrix == null);
+
+ return availableForTesting;
+ }
+
+ /** Ignore test for given vector type. */
+ private boolean likeMatrixSupported(Class<? extends Vector> clazz) {
+ for (Class<? extends Vector> ignoredClass : likeMatrixUnsupported)
+ if (ignoredClass.isAssignableFrom(clazz))
+ return false;
+
+ return true;
+ }
+
+ /** */
+ private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
+ new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
+ }
+
+ /** */
+ private static Map<Class<? extends Vector>, Class<? extends Matrix>> typesMap() {
+ return new LinkedHashMap<Class<? extends Vector>, Class<? extends Matrix>>() {{
+ put(DenseLocalOnHeapVector.class, DenseLocalOnHeapMatrix.class);
+ put(DenseLocalOffHeapVector.class, DenseLocalOffHeapMatrix.class);
+ put(RandomVector.class, RandomMatrix.class);
+ put(SparseLocalVector.class, SparseLocalOnHeapMatrix.class);
+ put(SingleElementVector.class, null); // todo find out if we need SingleElementMatrix to match, or skip it
+ put(ConstantVector.class, null);
+ put(FunctionVector.class, null);
+ put(PivotedVectorView.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
+ put(SingleElementVectorView.class, null);
+ put(MatrixVectorView.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
+ put(DelegatingVector.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
+ // IMPL NOTE check for presence of all implementations here will be done in testHaveLikeMatrix via Fixture
+ }};
+ }
+
+ /** */
+ private static class Metric { // todo consider if softer tolerance (like say 0.1 or 0.01) would make sense here
+ /** */
+ private final double exp;
+
+ /** */
+ private final double obtained;
+
+ /** **/
+ Metric(double exp, double obtained) {
+ this.exp = exp;
+ this.obtained = obtained;
+ }
+
+ /** */
+ boolean closeEnough() {
+ return new Double(exp).equals(obtained);
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ return "Metric{" + "expected=" + exp +
+ ", obtained=" + obtained +
+ '}';
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java
new file mode 100644
index 0000000..55893d0
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java
@@ -0,0 +1,162 @@
+/*
+ * 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.vector;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.function.BiConsumer;
+import java.util.stream.IntStream;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Unit tests for {@link VectorView}.
+ */
+public class VectorViewTest {
+ /** */
+ private static final int OFFSET = 10;
+
+ /** */
+ private static final int VIEW_LENGTH = 80;
+
+ /** */
+ private static final String EXTERNALIZE_TEST_FILE_NAME = "externalizeTest";
+
+ /** */
+ private VectorView testVector;
+
+ /** */
+ private DenseLocalOnHeapVector parentVector;
+
+ /** */
+ private double[] parentData;
+
+ /** */
+ @Before
+ public void setup() {
+ parentVector = new DenseLocalOnHeapVector(MathTestConstants.STORAGE_SIZE);
+
+ IntStream.range(0, MathTestConstants.STORAGE_SIZE).forEach(idx -> parentVector.set(idx, Math.random()));
+
+ parentData = parentVector.getStorage().data().clone();
+
+ testVector = new VectorView(parentVector, OFFSET, VIEW_LENGTH);
+ }
+
+ /** */
+ @AfterClass
+ public static void cleanup() throws IOException {
+ Files.deleteIfExists(Paths.get(EXTERNALIZE_TEST_FILE_NAME));
+ }
+
+ /** */
+ @Test
+ public void testCopy() throws Exception {
+ Vector cp = testVector.copy();
+
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, cp.equals(testVector));
+ }
+
+ /** */
+ @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
+ public void testLike() throws Exception {
+ for (int card : new int[] {1, 2, 4, 8, 16, 32, 64, 128})
+ consumeSampleVectors((v, desc) -> {
+ Vector vLike = new VectorView(v, 0, 1).like(card);
+
+ Class<? extends Vector> expType = v.getClass();
+
+ assertNotNull("Expect non-null like vector for " + expType.getSimpleName() + " in " + desc, vLike);
+
+ assertEquals("Expect size equal to cardinality at " + desc, card, vLike.size());
+
+ Class<? extends Vector> actualType = vLike.getClass();
+
+ assertTrue("Expected matrix type " + expType.getSimpleName()
+ + " should be assignable from actual type " + actualType.getSimpleName() + " in " + desc,
+ expType.isAssignableFrom(actualType));
+
+ });
+ }
+
+ /** See also {@link VectorToMatrixTest#testLikeMatrix()}. */
+ @Test
+ public void testLikeMatrix() {
+ consumeSampleVectors((v, desc) -> {
+ boolean expECaught = false;
+
+ try {
+ assertNull("Null view instead of exception in " + desc, new VectorView(v, 0, 1).likeMatrix(1, 1));
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception was not caught in " + desc, expECaught);
+ });
+ }
+
+ /** */
+ @Test
+ public void testWriteReadExternal() throws Exception {
+ assertNotNull("Unexpected null parent data", parentData);
+
+ File f = new File(EXTERNALIZE_TEST_FILE_NAME);
+
+ try {
+ ObjectOutputStream objOutputStream = new ObjectOutputStream(new FileOutputStream(f));
+
+ objOutputStream.writeObject(testVector);
+
+ objOutputStream.close();
+
+ ObjectInputStream objInputStream = new ObjectInputStream(new FileInputStream(f));
+
+ VectorView readVector = (VectorView)objInputStream.readObject();
+
+ objInputStream.close();
+
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, testVector.equals(readVector));
+ }
+ catch (ClassNotFoundException | IOException e) {
+ fail(e.getMessage());
+ }
+ }
+
+ /** */
+ private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
+ new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 9e9d877..b54e407 100644
--- a/pom.xml
+++ b/pom.xml
@@ -935,9 +935,9 @@
</profile>
<profile>
- <id>math</id>
+ <id>ml</id>
<modules>
- <module>modules/math</module>
+ <module>modules/ml</module>
</modules>
</profile>
</profiles>
[04/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java
new file mode 100644
index 0000000..88aa4fe
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java
@@ -0,0 +1,381 @@
+/*
+ * 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.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.impls.storage.matrix.FunctionMatrixStorage;
+import org.jetbrains.annotations.NotNull;
+
+/** */
+class MatrixImplementationFixtures {
+ /** */
+ private static final List<Supplier<Iterable<Matrix>>> suppliers = Arrays.asList(
+ (Supplier<Iterable<Matrix>>)DenseLocalOnHeapMatrixFixture::new,
+ (Supplier<Iterable<Matrix>>)DenseLocalOffHeapMatrixFixture::new,
+ (Supplier<Iterable<Matrix>>)RandomMatrixFixture::new,
+ (Supplier<Iterable<Matrix>>)SparseLocalOnHeapMatrixFixture::new,
+ (Supplier<Iterable<Matrix>>)PivotedMatrixViewFixture::new,
+ (Supplier<Iterable<Matrix>>)MatrixViewFixture::new,
+ (Supplier<Iterable<Matrix>>)FunctionMatrixFixture::new,
+ (Supplier<Iterable<Matrix>>)DiagonalMatrixFixture::new,
+ (Supplier<Iterable<Matrix>>)TransposedMatrixViewFixture::new
+ );
+
+ /** */
+ void consumeSampleMatrix(BiConsumer<Matrix, String> consumer) {
+ for (Supplier<Iterable<Matrix>> fixtureSupplier : suppliers) {
+ final Iterable<Matrix> fixture = fixtureSupplier.get();
+
+ for (Matrix matrix : fixture) {
+ consumer.accept(matrix, fixture.toString());
+
+ matrix.destroy();
+ }
+ }
+ }
+
+ /** */
+ private static class DenseLocalOnHeapMatrixFixture extends MatrixSizeIterator {
+ /** */
+ DenseLocalOnHeapMatrixFixture() {
+ super(DenseLocalOnHeapMatrix::new, "DenseLocalOnHeapMatrix");
+ }
+ }
+
+ /** */
+ private static class DenseLocalOffHeapMatrixFixture extends MatrixSizeIterator {
+ /** */
+ DenseLocalOffHeapMatrixFixture() {
+ super(DenseLocalOffHeapMatrix::new, "DenseLocalOffHeapMatrix");
+ }
+ }
+
+ /** */
+ private static class RandomMatrixFixture extends MatrixSizeIterator {
+ /** */
+ RandomMatrixFixture() {
+ super(RandomMatrix::new, "RandomMatrix");
+ }
+ }
+
+ /** */
+ private static class SparseLocalOnHeapMatrixFixture extends MatrixSizeIterator {
+ /** */
+ SparseLocalOnHeapMatrixFixture() {
+ super(SparseLocalOnHeapMatrix::new, "SparseLocalOnHeapMatrix");
+ }
+ }
+
+ /** */
+ private static class PivotedMatrixViewFixture extends WrapperMatrixIterator {
+ /** */
+ PivotedMatrixViewFixture() {
+ super(PivotedMatrixView::new, "PivotedMatrixView over DenseLocalOnHeapMatrix");
+ }
+ }
+
+ /** */
+ private static class MatrixViewFixture extends WrapperMatrixIterator {
+ /** */
+ MatrixViewFixture() {
+ super((matrix) -> new MatrixView(matrix, 0, 0, matrix.rowSize(), matrix.columnSize()),
+ "MatrixView over DenseLocalOnHeapMatrix");
+ }
+ }
+
+ /** */
+ private static class FunctionMatrixFixture extends WrapperMatrixIterator {
+ /** */
+ FunctionMatrixFixture() {
+ super(FunctionMatrixForTest::new, "FunctionMatrix wrapping DenseLocalOnHeapMatrix");
+ }
+ }
+
+ /** */
+ private static class DiagonalMatrixFixture extends DiagonalIterator {
+ /** */
+ DiagonalMatrixFixture() {
+ super(DenseLocalOnHeapMatrix::new, "DiagonalMatrix over DenseLocalOnHeapMatrix");
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Matrix> iterator() {
+ return new Iterator<Matrix>() {
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return hasNextSize(getSizeIdx());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix next() {
+ assert getSize(getSizeIdx()) == 1 : "Only size 1 allowed for diagonal matrix fixture.";
+
+ Matrix matrix = getConstructor().apply(getSize(getSizeIdx()), getSize(getSizeIdx()));
+
+ nextIdx();
+
+ return new DiagonalMatrix(matrix);
+ }
+ };
+ }
+ }
+
+ /** */
+ private static class TransposedMatrixViewFixture extends WrapperMatrixIterator {
+ /** */
+ TransposedMatrixViewFixture() {
+ super(TransposedMatrixView::new, "TransposedMatrixView over DenseLocalOnHeapMatrix");
+ }
+ }
+
+ /** */
+ private static abstract class DiagonalIterator implements Iterable<Matrix> {
+ /** */
+ private final Integer[] sizes = new Integer[] {1, null};
+ /** */
+ private int sizeIdx = 0;
+
+ /** */
+ private BiFunction<Integer, Integer, ? extends Matrix> constructor;
+ /** */
+ private String desc;
+
+ /** */
+ DiagonalIterator(BiFunction<Integer, Integer, ? extends Matrix> constructor, String desc) {
+ this.constructor = constructor;
+ this.desc = desc;
+ }
+
+ /** */
+ public BiFunction<Integer, Integer, ? extends Matrix> getConstructor() {
+ return constructor;
+ }
+
+ /** */
+ int getSizeIdx() {
+ return sizeIdx;
+ }
+
+ /** */
+ @Override public String toString() {
+ return desc + "{rows=" + sizes[sizeIdx] + ", cols=" + sizes[sizeIdx] + "}";
+ }
+
+ /** */
+ boolean hasNextSize(int idx) {
+ return sizes[idx] != null;
+ }
+
+ /** */
+ Integer getSize(int idx) {
+ return sizes[idx];
+ }
+
+ /** */
+ void nextIdx() {
+ sizeIdx++;
+ }
+ }
+
+ /** */
+ private static class WrapperMatrixIterator extends MatrixSizeIterator {
+ /** */
+ private final Function<Matrix, Matrix> wrapperCtor;
+
+ /** */
+ WrapperMatrixIterator(Function<Matrix, Matrix> wrapperCtor, String desc) {
+ super(DenseLocalOnHeapMatrix::new, desc);
+
+ this.wrapperCtor = wrapperCtor;
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Matrix> iterator() {
+ return new Iterator<Matrix>() {
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return hasNextCol(getSizeIdx()) && hasNextRow(getSizeIdx());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix next() {
+ Matrix matrix = getConstructor().apply(getRow(getSizeIdx()), getCol(getSizeIdx()));
+
+ nextIdx();
+
+ return wrapperCtor.apply(matrix);
+ }
+ };
+ }
+ }
+
+ /** */
+ private static class MatrixSizeIterator implements Iterable<Matrix> {
+ /** */
+ private final Integer[] rows = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 1024, null};
+ /** */
+ private final Integer[] cols = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 1024, 512, null};
+ /** */
+ private int sizeIdx = 0;
+
+ /** */
+ private BiFunction<Integer, Integer, ? extends Matrix> constructor;
+ /** */
+ private String desc;
+
+ /** */
+ MatrixSizeIterator(BiFunction<Integer, Integer, ? extends Matrix> constructor, String desc) {
+ this.constructor = constructor;
+ this.desc = desc;
+ }
+
+ /** */
+ public BiFunction<Integer, Integer, ? extends Matrix> getConstructor() {
+ return constructor;
+ }
+
+ /** */
+ int getSizeIdx() {
+ return sizeIdx;
+ }
+
+ /** */
+ @Override public String toString() {
+ return desc + "{rows=" + rows[sizeIdx] + ", cols=" + cols[sizeIdx] + "}";
+ }
+
+ /** */
+ boolean hasNextRow(int idx) {
+ return rows[idx] != null;
+ }
+
+ /** */
+ boolean hasNextCol(int idx) {
+ return cols[idx] != null;
+ }
+
+ /** */
+ Integer getRow(int idx) {
+ return rows[idx];
+ }
+
+ /** */
+ int getCol(int idx) {
+ return cols[idx];
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Matrix> iterator() {
+ return new Iterator<Matrix>() {
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return hasNextCol(sizeIdx) && hasNextRow(sizeIdx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix next() {
+ Matrix matrix = constructor.apply(rows[sizeIdx], cols[sizeIdx]);
+
+ nextIdx();
+
+ return matrix;
+ }
+ };
+ }
+
+ /** */
+ void nextIdx() {
+ sizeIdx++;
+ }
+ }
+
+ /** Subclass tweaked for serialization */
+ private static class FunctionMatrixForTest extends FunctionMatrix {
+ /** */
+ Matrix underlying;
+
+ /** */
+ public FunctionMatrixForTest() {
+ // No-op.
+ }
+
+ /** */
+ FunctionMatrixForTest(Matrix underlying) {
+ super(underlying.rowSize(), underlying.columnSize(), underlying::get, underlying::set);
+
+ this.underlying = underlying;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ return new FunctionMatrixForTest(underlying);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeObject(underlying);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ underlying = (Matrix)in.readObject();
+
+ setStorage(new FunctionMatrixStorage(underlying.rowSize(), underlying.columnSize(),
+ underlying::get, underlying::set));
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + underlying.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ FunctionMatrixForTest that = (FunctionMatrixForTest)o;
+
+ return underlying != null ? underlying.equals(that.underlying) : that.underlying == null;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java
new file mode 100644
index 0000000..28abab7
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java
@@ -0,0 +1,1113 @@
+/*
+ * 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.matrix;
+
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+import org.apache.ignite.math.ExternalizeTest;
+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.ColumnIndexException;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.exceptions.RowIndexException;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.apache.ignite.math.impls.vector.RandomVector;
+import org.apache.ignite.math.impls.vector.SparseLocalVector;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests for {@link Matrix} implementations.
+ */
+public class MatrixImplementationsTest extends ExternalizeTest<Matrix> {
+ /** */
+ private static final double DEFAULT_DELTA = 0.000000001d;
+
+ /** */
+ private void consumeSampleMatrix(BiConsumer<Matrix, String> consumer) {
+ new MatrixImplementationFixtures().consumeSampleMatrix(consumer);
+ }
+
+ /** */
+ @Test
+ public void externalizeTest() {
+ consumeSampleMatrix((m, desc) -> externalizeTest(m));
+ }
+
+ /** */
+ @Test
+ public void testLike() {
+ consumeSampleMatrix((m, desc) -> {
+ Class<? extends Matrix> cls = likeMatrixType(m);
+
+ if (cls != null) {
+ Matrix like = m.like(m.rowSize(), m.columnSize());
+
+ assertEquals("Wrong \"like\" matrix for " + desc + "; Unexpected rows.", like.rowSize(), m.rowSize());
+ assertEquals("Wrong \"like\" matrix for " + desc + "; Unexpected columns.", like.columnSize(), m.columnSize());
+
+ assertEquals("Wrong \"like\" matrix for " + desc
+ + "; Unexpected class: " + like.getClass().toString(),
+ cls,
+ like.getClass());
+
+ return;
+ }
+
+ boolean expECaught = false;
+
+ try {
+ m.like(1, 1);
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception was not caught for " + desc, expECaught);
+ });
+ }
+
+ /** */
+ @Test
+ public void testCopy() {
+ consumeSampleMatrix((m, desc) -> {
+ Matrix cp = m.copy();
+ assertTrue("Incorrect copy for empty matrix " + desc, cp.equals(m));
+
+ if (!readOnly(m))
+ fillMatrix(m);
+
+ cp = m.copy();
+
+ assertTrue("Incorrect copy for matrix " + desc, cp.equals(m));
+ });
+ }
+
+ /** */
+ @Test
+ public void testHaveLikeVector() throws InstantiationException, IllegalAccessException {
+ for (Class<? extends Matrix> key : likeVectorTypesMap().keySet()) {
+ Class<? extends Vector> val = likeVectorTypesMap().get(key);
+
+ if (val == null && !ignore(key))
+ System.out.println("Missing test for implementation of likeMatrix for " + key.getSimpleName());
+ }
+ }
+
+ /** */
+ @Test
+ public void testLikeVector() {
+ consumeSampleMatrix((m, desc) -> {
+ if (likeVectorTypesMap().containsKey(m.getClass())) {
+ Vector likeVector = m.likeVector(m.columnSize());
+
+ assertNotNull(likeVector);
+ assertEquals("Unexpected value for " + desc, likeVector.size(), m.columnSize());
+
+ return;
+ }
+
+ boolean expECaught = false;
+
+ try {
+ m.likeVector(1);
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception was not caught for " + desc, expECaught);
+ });
+ }
+
+ /** */
+ @Test
+ public void testAssignSingleElement() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ final double assignVal = Math.random();
+
+ m.assign(assignVal);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ assignVal, m.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testAssignArray() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] data = new double[m.rowSize()][m.columnSize()];
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ data[i][j] = Math.random();
+
+ m.assign(data);
+
+ for (int i = 0; i < m.rowSize(); i++) {
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ data[i][j], m.get(i, j), 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testAssignFunction() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ m.assign((i, j) -> (double)(i * m.columnSize() + j));
+
+ for (int i = 0; i < m.rowSize(); i++) {
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ (double)(i * m.columnSize() + j), m.get(i, j), 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testPlus() {
+ consumeSampleMatrix((m, desc) -> {
+ if (readOnly(m))
+ return;
+
+ double[][] data = fillAndReturn(m);
+
+ double plusVal = Math.random();
+
+ Matrix plus = m.plus(plusVal);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ data[i][j] + plusVal, plus.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testPlusMatrix() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] data = fillAndReturn(m);
+
+ Matrix plus = m.plus(m);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ data[i][j] * 2.0, plus.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testMinusMatrix() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ Matrix minus = m.minus(m);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ 0.0, minus.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testTimes() {
+ consumeSampleMatrix((m, desc) -> {
+ if (readOnly(m))
+ return;
+
+ double[][] data = fillAndReturn(m);
+
+ double timeVal = Math.random();
+ Matrix times = m.times(timeVal);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ data[i][j] * timeVal, times.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testTimesVector() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] data = fillAndReturn(m);
+
+ double[] arr = fillArray(m.columnSize());
+
+ Vector times = m.times(new DenseLocalOnHeapVector(arr));
+
+ assertEquals("Unexpected vector size for " + desc, times.size(), m.rowSize());
+
+ for (int i = 0; i < m.rowSize(); i++) {
+ double exp = 0.0;
+
+ for (int j = 0; j < m.columnSize(); j++)
+ exp += arr[j] * data[i][j];
+
+ assertEquals("Unexpected value for " + desc + " at " + i,
+ times.get(i), exp, 0d);
+ }
+
+ testInvalidCardinality(() -> m.times(new DenseLocalOnHeapVector(m.columnSize() + 1)), desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void testTimesMatrix() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] data = fillAndReturn(m);
+
+ double[] arr = fillArray(m.columnSize());
+
+ Matrix mult = new DenseLocalOnHeapMatrix(m.columnSize(), 1);
+
+ mult.setColumn(0, arr);
+
+ Matrix times = m.times(mult);
+
+ assertEquals("Unexpected rows for " + desc, times.rowSize(), m.rowSize());
+
+ assertEquals("Unexpected cols for " + desc, times.columnSize(), 1);
+
+ for (int i = 0; i < m.rowSize(); i++) {
+ double exp = 0.0;
+
+ for (int j = 0; j < m.columnSize(); j++)
+ exp += arr[j] * data[i][j];
+
+ assertEquals("Unexpected value for " + desc + " at " + i,
+ exp, times.get(i, 0), 0d);
+ }
+
+ testInvalidCardinality(() -> m.times(new DenseLocalOnHeapMatrix(m.columnSize() + 1, 1)), desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void testDivide() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] data = fillAndReturn(m);
+
+ double divVal = Math.random();
+
+ Matrix divide = m.divide(divVal);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ data[i][j] / divVal, divide.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testTranspose() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ Matrix transpose = m.transpose();
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ m.get(i, j), transpose.get(j, i), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testDeterminant() {
+ consumeSampleMatrix((m, desc) -> {
+ if (m.rowSize() != m.columnSize())
+ return;
+
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] doubles = fillIntAndReturn(m);
+
+ if (m.rowSize() == 1) {
+ assertEquals("Unexpected value " + desc, m.determinant(), doubles[0][0], 0d);
+
+ return;
+ }
+
+ if (m.rowSize() == 2) {
+ double det = doubles[0][0] * doubles[1][1] - doubles[0][1] * doubles[1][0];
+ assertEquals("Unexpected value " + desc, m.determinant(), det, 0d);
+
+ return;
+ }
+
+ if (m.rowSize() > 512)
+ return; // IMPL NOTE if row size >= 30000 it takes unacceptably long for normal test run.
+
+ Matrix diagMtx = m.like(m.rowSize(), m.columnSize());
+
+ diagMtx.assign(0);
+ for (int i = 0; i < m.rowSize(); i++)
+ diagMtx.set(i, i, m.get(i, i));
+
+ double det = 1;
+
+ for (int i = 0; i < diagMtx.rowSize(); i++)
+ det *= diagMtx.get(i, i);
+
+ try {
+ assertEquals("Unexpected value " + desc, det, diagMtx.determinant(), DEFAULT_DELTA);
+ }
+ catch (Exception e) {
+ System.out.println(desc);
+ throw e;
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testInverse() {
+ consumeSampleMatrix((m, desc) -> {
+ if (m.rowSize() != m.columnSize())
+ return;
+
+ if (ignore(m.getClass()))
+ return;
+
+ if (m.rowSize() > 256)
+ return; // IMPL NOTE this is for quicker test run.
+
+ fillNonSingularMatrix(m);
+
+ assertTrue("Unexpected zero determinant " + desc, Math.abs(m.determinant()) > 0d);
+
+ Matrix inverse = m.inverse();
+
+ Matrix mult = m.times(inverse);
+
+ final double delta = 0.001d;
+
+ assertEquals("Unexpected determinant " + desc, 1d, mult.determinant(), delta);
+
+ assertEquals("Unexpected top left value " + desc, 1d, mult.get(0, 0), delta);
+
+ if (m.rowSize() == 1)
+ return;
+
+ assertEquals("Unexpected center value " + desc,
+ 1d, mult.get(m.rowSize() / 2, m.rowSize() / 2), delta);
+
+ assertEquals("Unexpected bottom right value " + desc,
+ 1d, mult.get(m.rowSize() - 1, m.rowSize() - 1), delta);
+
+ assertEquals("Unexpected top right value " + desc,
+ 0d, mult.get(0, m.rowSize() - 1), delta);
+
+ assertEquals("Unexpected bottom left value " + desc,
+ 0d, mult.get(m.rowSize() - 1, 0), delta);
+ });
+ }
+
+ /** */
+ @Test
+ public void testMap() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ m.map(x -> 10d);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ 10d, m.get(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testMapMatrix() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ double[][] doubles = fillAndReturn(m);
+
+ testMapMatrixWrongCardinality(m, desc);
+
+ Matrix cp = m.copy();
+
+ m.map(cp, (m1, m2) -> m1 + m2);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ m.get(i, j), doubles[i][j] * 2, 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testViewRow() {
+ consumeSampleMatrix((m, desc) -> {
+ if (!readOnly(m))
+ fillMatrix(m);
+
+ for (int i = 0; i < m.rowSize(); i++) {
+ Vector vector = m.viewRow(i);
+ assert vector != null;
+
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ m.get(i, j), vector.get(j), 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testViewCol() {
+ consumeSampleMatrix((m, desc) -> {
+ if (!readOnly(m))
+ fillMatrix(m);
+
+ for (int i = 0; i < m.columnSize(); i++) {
+ Vector vector = m.viewColumn(i);
+ assert vector != null;
+
+ for (int j = 0; j < m.rowSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
+ m.get(j, i), vector.get(j), 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testFoldRow() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ Vector foldRows = m.foldRows(Vector::sum);
+
+ for (int i = 0; i < m.rowSize(); i++) {
+ Double locSum = 0d;
+
+ for (int j = 0; j < m.columnSize(); j++)
+ locSum += m.get(i, j);
+
+ assertEquals("Unexpected value for " + desc + " at " + i,
+ foldRows.get(i), locSum, 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testFoldCol() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ Vector foldCols = m.foldColumns(Vector::sum);
+
+ for (int j = 0; j < m.columnSize(); j++) {
+ Double locSum = 0d;
+
+ for (int i = 0; i < m.rowSize(); i++)
+ locSum += m.get(i, j);
+
+ assertEquals("Unexpected value for " + desc + " at " + j,
+ foldCols.get(j), locSum, 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testSum() {
+ consumeSampleMatrix((m, desc) -> {
+ double[][] data = fillAndReturn(m);
+
+ double sum = m.sum();
+
+ double rawSum = 0;
+ for (double[] anArr : data)
+ for (int j = 0; j < data[0].length; j++)
+ rawSum += anArr[j];
+
+ assertEquals("Unexpected value for " + desc,
+ rawSum, sum, 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testMax() {
+ consumeSampleMatrix((m, desc) -> {
+ double[][] doubles = fillAndReturn(m);
+ double max = Double.NEGATIVE_INFINITY;
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ max = max < doubles[i][j] ? doubles[i][j] : max;
+
+ assertEquals("Unexpected value for " + desc, m.maxValue(), max, 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testMin() {
+ consumeSampleMatrix((m, desc) -> {
+ double[][] doubles = fillAndReturn(m);
+ double min = Double.MAX_VALUE;
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ min = min > doubles[i][j] ? doubles[i][j] : min;
+
+ assertEquals("Unexpected value for " + desc, m.minValue(), min, 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testGetElement() {
+ consumeSampleMatrix((m, desc) -> {
+ if (!(readOnly(m)))
+ fillMatrix(m);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++) {
+ final Matrix.Element e = m.getElement(i, j);
+
+ final String details = desc + " at [" + i + "," + j + "]";
+
+ assertEquals("Unexpected element row " + details, i, e.row());
+ assertEquals("Unexpected element col " + details, j, e.column());
+
+ final double val = m.get(i, j);
+
+ assertEquals("Unexpected value for " + details, val, e.get(), 0d);
+
+ boolean expECaught = false;
+
+ final double newVal = val * 2.0;
+
+ try {
+ e.set(newVal);
+ }
+ catch (UnsupportedOperationException uoe) {
+ if (!(readOnly(m)))
+ throw uoe;
+
+ expECaught = true;
+ }
+
+ if (readOnly(m)) {
+ if (!expECaught)
+ fail("Expected exception was not caught for " + details);
+
+ continue;
+ }
+
+ assertEquals("Unexpected value set for " + details, newVal, m.get(i, j), 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testGetX() {
+ consumeSampleMatrix((m, desc) -> {
+ if (!(readOnly(m)))
+ fillMatrix(m);
+
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ assertEquals("Unexpected value for " + desc + " at [" + i + "," + j + "]",
+ m.get(i, j), m.getX(i, j), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testGetMetaStorage() {
+ consumeSampleMatrix((m, desc) -> assertNotNull("Null meta storage in " + desc, m.getMetaStorage()));
+ }
+
+ /** */
+ @Test
+ public void testGuid() {
+ consumeSampleMatrix((m, desc) -> assertNotNull("Null guid in " + desc, m.guid()));
+ }
+
+ /** */
+ @Test
+ public void testSwapRows() {
+ consumeSampleMatrix((m, desc) -> {
+ if (readOnly(m))
+ return;
+
+ double[][] doubles = fillAndReturn(m);
+
+ final int swap_i = m.rowSize() == 1 ? 0 : 1;
+ final int swap_j = 0;
+
+ Matrix swap = m.swapRows(swap_i, swap_j);
+
+ for (int col = 0; col < m.columnSize(); col++) {
+ assertEquals("Unexpected value for " + desc + " at col " + col + ", swap_i " + swap_i,
+ swap.get(swap_i, col), doubles[swap_j][col], 0d);
+
+ assertEquals("Unexpected value for " + desc + " at col " + col + ", swap_j " + swap_j,
+ swap.get(swap_j, col), doubles[swap_i][col], 0d);
+ }
+
+ testInvalidRowIndex(() -> m.swapRows(-1, 0), desc + " negative first swap index");
+ testInvalidRowIndex(() -> m.swapRows(0, -1), desc + " negative second swap index");
+ testInvalidRowIndex(() -> m.swapRows(m.rowSize(), 0), desc + " too large first swap index");
+ testInvalidRowIndex(() -> m.swapRows(0, m.rowSize()), desc + " too large second swap index");
+ });
+ }
+
+ /** */
+ @Test
+ public void testSwapColumns() {
+ consumeSampleMatrix((m, desc) -> {
+ if (readOnly(m))
+ return;
+
+ double[][] doubles = fillAndReturn(m);
+
+ final int swap_i = m.columnSize() == 1 ? 0 : 1;
+ final int swap_j = 0;
+
+ Matrix swap = m.swapColumns(swap_i, swap_j);
+
+ for (int row = 0; row < m.rowSize(); row++) {
+ assertEquals("Unexpected value for " + desc + " at row " + row + ", swap_i " + swap_i,
+ swap.get(row, swap_i), doubles[row][swap_j], 0d);
+
+ assertEquals("Unexpected value for " + desc + " at row " + row + ", swap_j " + swap_j,
+ swap.get(row, swap_j), doubles[row][swap_i], 0d);
+ }
+
+ testInvalidColIndex(() -> m.swapColumns(-1, 0), desc + " negative first swap index");
+ testInvalidColIndex(() -> m.swapColumns(0, -1), desc + " negative second swap index");
+ testInvalidColIndex(() -> m.swapColumns(m.columnSize(), 0), desc + " too large first swap index");
+ testInvalidColIndex(() -> m.swapColumns(0, m.columnSize()), desc + " too large second swap index");
+ });
+ }
+
+ /** */
+ @Test
+ public void testSetRow() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ int rowIdx = m.rowSize() / 2;
+
+ double[] newValues = fillArray(m.columnSize());
+
+ m.setRow(rowIdx, newValues);
+
+ for (int col = 0; col < m.columnSize(); col++)
+ assertEquals("Unexpected value for " + desc + " at " + col,
+ newValues[col], m.get(rowIdx, col), 0d);
+
+ testInvalidCardinality(() -> m.setRow(rowIdx, new double[m.columnSize() + 1]), desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void testSetColumn() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ int colIdx = m.columnSize() / 2;
+
+ double[] newValues = fillArray(m.rowSize());
+
+ m.setColumn(colIdx, newValues);
+
+ for (int row = 0; row < m.rowSize(); row++)
+ assertEquals("Unexpected value for " + desc + " at " + row,
+ newValues[row], m.get(row, colIdx), 0d);
+
+ testInvalidCardinality(() -> m.setColumn(colIdx, new double[m.rowSize() + 1]), desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void testViewPart() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ int rowOff = m.rowSize() < 3 ? 0 : 1;
+ int rows = m.rowSize() < 3 ? 1 : m.rowSize() - 2;
+ int colOff = m.columnSize() < 3 ? 0 : 1;
+ int cols = m.columnSize() < 3 ? 1 : m.columnSize() - 2;
+
+ Matrix view1 = m.viewPart(rowOff, rows, colOff, cols);
+ Matrix view2 = m.viewPart(new int[] {rowOff, colOff}, new int[] {rows, cols});
+
+ String details = desc + " view [" + rowOff + ", " + rows + ", " + colOff + ", " + cols + "]";
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++) {
+ assertEquals("Unexpected view1 value for " + details + " at (" + i + "," + j + ")",
+ m.get(i + rowOff, j + colOff), view1.get(i, j), 0d);
+
+ assertEquals("Unexpected view2 value for " + details + " at (" + i + "," + j + ")",
+ m.get(i + rowOff, j + colOff), view2.get(i, j), 0d);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ public void testDensity() {
+ consumeSampleMatrix((m, desc) -> {
+ if (!readOnly(m))
+ fillMatrix(m);
+
+ assertTrue("Unexpected density with threshold 0 for " + desc, m.density(0.0));
+
+ assertFalse("Unexpected density with threshold 1 for " + desc, m.density(1.0));
+ });
+ }
+
+ /** */
+ @Test
+ public void testMaxAbsRowSumNorm() {
+ consumeSampleMatrix((m, desc) -> {
+ if (!readOnly(m))
+ fillMatrix(m);
+
+ assertEquals("Unexpected value for " + desc,
+ maxAbsRowSumNorm(m), m.maxAbsRowSumNorm(), 0d);
+ });
+ }
+
+ /** */
+ @Test
+ public void testAssignRow() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ int rowIdx = m.rowSize() / 2;
+
+ double[] newValues = fillArray(m.columnSize());
+
+ m.assignRow(rowIdx, new DenseLocalOnHeapVector(newValues));
+
+ for (int col = 0; col < m.columnSize(); col++)
+ assertEquals("Unexpected value for " + desc + " at " + col,
+ newValues[col], m.get(rowIdx, col), 0d);
+
+ testInvalidCardinality(() -> m.assignRow(rowIdx, new DenseLocalOnHeapVector(m.columnSize() + 1)), desc);
+ });
+ }
+
+ /** */
+ @Test
+ public void testAssignColumn() {
+ consumeSampleMatrix((m, desc) -> {
+ if (ignore(m.getClass()))
+ return;
+
+ fillMatrix(m);
+
+ int colIdx = m.columnSize() / 2;
+
+ double[] newValues = fillArray(m.rowSize());
+
+ m.assignColumn(colIdx, new DenseLocalOnHeapVector(newValues));
+
+ for (int row = 0; row < m.rowSize(); row++)
+ assertEquals("Unexpected value for " + desc + " at " + row,
+ newValues[row], m.get(row, colIdx), 0d);
+ });
+ }
+
+ /** */
+ private double[] fillArray(int len) {
+ double[] newValues = new double[len];
+
+ for (int i = 0; i < newValues.length; i++)
+ newValues[i] = newValues.length - i;
+ return newValues;
+ }
+
+ /** */
+ private double maxAbsRowSumNorm(Matrix m) {
+ double max = 0.0;
+
+ for (int x = 0; x < m.rowSize(); x++) {
+ double sum = 0;
+
+ for (int y = 0; y < m.columnSize(); y++)
+ sum += Math.abs(m.getX(x, y));
+
+ if (sum > max)
+ max = sum;
+ }
+
+ return max;
+ }
+
+ /** */
+ private void testInvalidRowIndex(Supplier<Matrix> supplier, String desc) {
+ try {
+ supplier.get();
+ }
+ catch (RowIndexException | IndexException ie) {
+ return;
+ }
+
+ fail("Expected exception was not caught for " + desc);
+ }
+
+ /** */
+ private void testInvalidColIndex(Supplier<Matrix> supplier, String desc) {
+ try {
+ supplier.get();
+ }
+ catch (ColumnIndexException | IndexException ie) {
+ return;
+ }
+
+ fail("Expected exception was not caught for " + desc);
+ }
+
+ /** */
+ private void testMapMatrixWrongCardinality(Matrix m, String desc) {
+ for (int rowDelta : new int[] {-1, 0, 1})
+ for (int colDelta : new int[] {-1, 0, 1}) {
+ if (rowDelta == 0 && colDelta == 0)
+ continue;
+
+ int rowNew = m.rowSize() + rowDelta;
+ int colNew = m.columnSize() + colDelta;
+
+ if (rowNew < 1 || colNew < 1)
+ continue;
+
+ testInvalidCardinality(() -> m.map(new DenseLocalOnHeapMatrix(rowNew, colNew), (m1, m2) -> m1 + m2),
+ desc + " wrong cardinality when mapping to size " + rowNew + "x" + colNew);
+ }
+ }
+
+ /** */
+ private void testInvalidCardinality(Supplier<Object> supplier, String desc) {
+ try {
+ supplier.get();
+ }
+ catch (CardinalityException ce) {
+ return;
+ }
+
+ fail("Expected exception was not caught for " + desc);
+ }
+
+ /** */
+ private boolean readOnly(Matrix m) {
+ return m instanceof RandomMatrix;
+ }
+
+ /** */
+ private double[][] fillIntAndReturn(Matrix m) {
+ double[][] data = new double[m.rowSize()][m.columnSize()];
+
+ if (readOnly(m)) {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ data[i][j] = m.get(i, j);
+
+ }
+ else {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ data[i][j] = i * m.rowSize() + j + 1;
+
+ m.assign(data);
+ }
+ return data;
+ }
+
+ /** */
+ private double[][] fillAndReturn(Matrix m) {
+ double[][] data = new double[m.rowSize()][m.columnSize()];
+
+ if (readOnly(m)) {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ data[i][j] = m.get(i, j);
+
+ }
+ else {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ data[i][j] = -0.5d + Math.random();
+
+ m.assign(data);
+ }
+ return data;
+ }
+
+ /** */
+ private void fillNonSingularMatrix(Matrix m) {
+ for (int i = 0; i < m.rowSize(); i++) {
+ m.set(i, i, 10);
+
+ for (int j = 0; j < m.columnSize(); j++)
+ if (j != i)
+ m.set(i, j, 0.01d);
+ }
+ }
+
+ /** */
+ private void fillMatrix(Matrix m) {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ m.set(i, j, Math.random());
+ }
+
+ /** Ignore test for given matrix type. */
+ private boolean ignore(Class<? extends Matrix> clazz) {
+ List<Class<? extends Matrix>> ignoredClasses = Arrays.asList(RandomMatrix.class, PivotedMatrixView.class,
+ MatrixView.class, FunctionMatrix.class, TransposedMatrixView.class);
+
+ for (Class<? extends Matrix> ignoredClass : ignoredClasses)
+ if (ignoredClass.isAssignableFrom(clazz))
+ return true;
+
+ return false;
+ }
+
+ /** */
+ private Class<? extends Matrix> likeMatrixType(Matrix m) {
+ for (Class<? extends Matrix> clazz : likeTypesMap().keySet())
+ if (clazz.isAssignableFrom(m.getClass()))
+ return likeTypesMap().get(clazz);
+
+ return null;
+ }
+
+ /** */
+ private static Map<Class<? extends Matrix>, Class<? extends Vector>> likeVectorTypesMap() {
+ return new LinkedHashMap<Class<? extends Matrix>, Class<? extends Vector>>() {{
+ put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapVector.class);
+ put(DenseLocalOffHeapMatrix.class, DenseLocalOffHeapVector.class);
+ put(RandomMatrix.class, RandomVector.class);
+ put(SparseLocalOnHeapMatrix.class, SparseLocalVector.class);
+ put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapVector.class);
+ put(DiagonalMatrix.class, DenseLocalOnHeapVector.class); // IMPL NOTE per fixture
+ // IMPL NOTE check for presence of all implementations here will be done in testHaveLikeMatrix via Fixture
+ }};
+ }
+
+ /** */
+ private static Map<Class<? extends Matrix>, Class<? extends Matrix>> likeTypesMap() {
+ return new LinkedHashMap<Class<? extends Matrix>, Class<? extends Matrix>>() {{
+ put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapMatrix.class);
+ put(DenseLocalOffHeapMatrix.class, DenseLocalOffHeapMatrix.class);
+ put(RandomMatrix.class, RandomMatrix.class);
+ put(SparseLocalOnHeapMatrix.class, SparseLocalOnHeapMatrix.class);
+ put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapMatrix.class);
+ put(DiagonalMatrix.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
+ put(FunctionMatrix.class, FunctionMatrix.class);
+ // IMPL NOTE check for presence of all implementations here will be done in testHaveLikeMatrix via Fixture
+ }};
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java
new file mode 100644
index 0000000..90fbec4
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java
@@ -0,0 +1,69 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.MatrixKeyMapper;
+
+/** */
+public class MatrixKeyMapperForTests implements MatrixKeyMapper<Integer> {
+ /** */ private int rows;
+ /** */ private int cols;
+
+ /** */
+ public MatrixKeyMapperForTests() {
+ // No-op.
+ }
+
+ /** */
+ public MatrixKeyMapperForTests(int rows, int cols) {
+ this.rows = rows;
+ this.cols = cols;
+ }
+
+ /** */
+ @Override public Integer apply(int x, int y) {
+ return x * cols + y;
+ }
+
+ /** */
+ @Override public boolean isValid(Integer integer) {
+ return (rows * cols) > integer;
+ }
+
+ /** */
+ @Override public int hashCode() {
+ int hash = 1;
+
+ hash += hash * 31 + rows;
+ hash += hash * 31 + cols;
+
+ return hash;
+ }
+
+ /** */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ MatrixKeyMapperForTests that = (MatrixKeyMapperForTests)obj;
+
+ return rows == that.rows && cols == that.cols;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java
new file mode 100644
index 0000000..01278da
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java
@@ -0,0 +1,114 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.impls.storage.matrix.MatrixDelegateStorage;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class MatrixViewConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ Matrix m = new DenseLocalOnHeapMatrix(1, 1);
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView((Matrix)null, 0, 0, 1, 1),
+ "Null parent matrix.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, -1, 0, 1, 1),
+ "Invalid row offset.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, 0, -1, 1, 1),
+ "Invalid col offset.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, 0, 0, 0, 1),
+ "Invalid rows.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, 0, 0, 1, 0),
+ "Invalid cols.");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ for (Matrix m : new Matrix[] {
+ new DenseLocalOnHeapMatrix(3, 3),
+ new DenseLocalOnHeapMatrix(3, 4), new DenseLocalOnHeapMatrix(4, 3)})
+ for (int rowOff : new int[] {0, 1})
+ for (int colOff : new int[] {0, 1})
+ for (int rows : new int[] {1, 2})
+ for (int cols : new int[] {1, 2})
+ basicTest(m, rowOff, colOff, rows, cols);
+ }
+
+ /** */
+ private void basicTest(Matrix parent, int rowOff, int colOff, int rows, int cols) {
+ for (int row = 0; row < parent.rowSize(); row++)
+ for (int col = 0; col < parent.columnSize(); col++)
+ parent.set(row, col, row * parent.columnSize() + col + 1);
+
+ Matrix view = new MatrixView(parent, rowOff, colOff, rows, cols);
+
+ assertEquals("Rows in view.", rows, view.rowSize());
+ assertEquals("Cols in view.", cols, view.columnSize());
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++)
+ assertEquals("Unexpected value at " + row + "x" + col,
+ parent.get(row + rowOff, col + colOff), view.get(row, col), 0d);
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++)
+ view.set(row, col, 0d);
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++)
+ assertEquals("Unexpected value set at " + row + "x" + col,
+ 0d, parent.get(row + rowOff, col + colOff), 0d);
+ }
+
+ /** */
+ @Test
+ public void attributeTest() {
+ for (Matrix m : new Matrix[] {
+ new DenseLocalOnHeapMatrix(3, 3),
+ new DenseLocalOnHeapMatrix(3, 4), new DenseLocalOnHeapMatrix(4, 3)}) {
+ MatrixView matrixView = new MatrixView(m, 0, 0, m.rowSize(), m.columnSize());
+
+ MatrixDelegateStorage delegateStorage = (MatrixDelegateStorage)matrixView.getStorage();
+
+ assertEquals(m.rowSize(), matrixView.rowSize());
+ assertEquals(m.columnSize(), matrixView.columnSize());
+
+ assertEquals(m.rowSize(), (delegateStorage).rowsLength());
+ assertEquals(m.columnSize(), (delegateStorage).columnsLength());
+
+ assertEquals(m.isSequentialAccess(), delegateStorage.isSequentialAccess());
+ assertEquals(m.isRandomAccess(), delegateStorage.isRandomAccess());
+ assertEquals(m.isDistributed(), delegateStorage.isDistributed());
+ assertEquals(m.isDense(), delegateStorage.isDense());
+ assertEquals(m.isArrayBased(), delegateStorage.isArrayBased());
+
+ assertArrayEquals(m.getStorage().data(), delegateStorage.data());
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java
new file mode 100644
index 0000000..a495745
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java
@@ -0,0 +1,128 @@
+/*
+ * 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.matrix;
+
+import java.util.Arrays;
+import org.apache.ignite.math.Matrix;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class PivotedMatrixViewConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ Matrix m = new DenseLocalOnHeapMatrix(1, 1);
+
+ int[] pivot = new int[] {0};
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(null),
+ "Null parent matrix.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(null, pivot),
+ "Null parent matrix, with pivot.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(m, null),
+ "Null pivot.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(m, null, pivot),
+ "Null row pivot.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(m, pivot, null),
+ "Null col pivot.");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ Matrix m = new DenseLocalOnHeapMatrix(2, 2);
+
+ int[] pivot = new int[] {0, 1};
+
+ PivotedMatrixView view = new PivotedMatrixView(m, pivot);
+
+ assertEquals("Rows in view.", m.rowSize(), view.rowSize());
+ assertEquals("Cols in view.", m.columnSize(), view.columnSize());
+
+ assertTrue("Row pivot array in view.", Arrays.equals(pivot, view.rowPivot()));
+ assertTrue("Col pivot array in view.", Arrays.equals(pivot, view.columnPivot()));
+
+ assertEquals("Base matrix in view.", m, view.getBaseMatrix());
+
+ assertEquals("Row pivot value in view.", 0, view.rowPivot(0));
+ assertEquals("Col pivot value in view.", 0, view.columnPivot(0));
+
+ assertEquals("Row unpivot value in view.", 0, view.rowUnpivot(0));
+ assertEquals("Col unpivot value in view.", 0, view.columnUnpivot(0));
+
+ Matrix swap = view.swap(1, 1);
+
+ for (int row = 0; row < view.rowSize(); row++)
+ for (int col = 0; col < view.columnSize(); col++)
+ assertEquals("Unexpected swap value set at (" + row + "," + col + ").",
+ view.get(row, col), swap.get(row, col), 0d);
+
+ //noinspection EqualsWithItself
+ assertTrue("View is expected to be equal to self.", view.equals(view));
+ //noinspection ObjectEqualsNull
+ assertFalse("View is expected to be not equal to null.", view.equals(null));
+ }
+
+ /** */
+ @Test
+ public void pivotTest() {
+ int[] pivot = new int[] {2, 1, 0, 3};
+
+ for (Matrix m : new Matrix[] {
+ new DenseLocalOnHeapMatrix(3, 3),
+ new DenseLocalOnHeapMatrix(3, 4), new DenseLocalOnHeapMatrix(4, 3)})
+ pivotTest(m, pivot);
+ }
+
+ /** */
+ private void pivotTest(Matrix parent, int[] pivot) {
+ for (int row = 0; row < parent.rowSize(); row++)
+ for (int col = 0; col < parent.columnSize(); col++)
+ parent.set(row, col, row * parent.columnSize() + col + 1);
+
+ Matrix view = new PivotedMatrixView(parent, pivot);
+
+ int rows = parent.rowSize();
+ int cols = parent.columnSize();
+
+ assertEquals("Rows in view.", rows, view.rowSize());
+ assertEquals("Cols in view.", cols, view.columnSize());
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++)
+ assertEquals("Unexpected value at " + row + "x" + col,
+ parent.get(pivot[row], pivot[col]), view.get(row, col), 0d);
+
+ int min = rows < cols ? rows : cols;
+
+ for (int idx = 0; idx < min; idx++)
+ view.set(idx, idx, 0d);
+
+ for (int idx = 0; idx < min; idx++)
+ assertEquals("Unexpected value set at " + idx,
+ 0d, parent.get(pivot[idx], pivot[idx]), 0d);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java
new file mode 100644
index 0000000..e19cfa3
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java
@@ -0,0 +1,71 @@
+/*
+ * 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.matrix;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class RandomMatrixConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(0, 1), "invalid row parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(1, 0), "invalid col parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(0, 1, true), "invalid row parameter, fastHash true");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(1, 0, true), "invalid col parameter, fastHash true");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(0, 1, false), "invalid row parameter, fastHash false");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(1, 0, false), "invalid col parameter, fastHash false");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ assertEquals("Expected number of rows, int parameters.", 1,
+ new RandomMatrix(1, 2).rowSize());
+
+ assertEquals("Expected number of cols, int parameters.", 1,
+ new RandomMatrix(2, 1).columnSize());
+
+ assertEquals("Expected number of rows, int parameters, fastHash true.", 1,
+ new RandomMatrix(1, 2, true).rowSize());
+
+ assertEquals("Expected number of cols, int parameters, fastHash true.", 1,
+ new RandomMatrix(2, 1, true).columnSize());
+
+ assertEquals("Expected number of rows, int parameters, fastHash false.", 1,
+ new RandomMatrix(1, 2, false).rowSize());
+
+ assertEquals("Expected number of cols, int parameters, fastHash false.", 1,
+ new RandomMatrix(2, 1, false).columnSize());
+
+ RandomMatrix m = new RandomMatrix(1, 1);
+ //noinspection EqualsWithItself
+ assertTrue("Matrix is expected to be equal to self.", m.equals(m));
+ //noinspection ObjectEqualsNull
+ assertFalse("Matrix is expected to be not equal to null.", m.equals(null));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java
new file mode 100644
index 0000000..8218a12
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java
@@ -0,0 +1,265 @@
+// @java.file.header
+
+/* _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+/*
+ * 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.matrix;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.internal.util.IgniteUtils;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.apache.ignite.testframework.junits.common.GridCommonTest;
+
+import static org.apache.ignite.math.impls.MathTestConstants.UNEXPECTED_VAL;
+
+/**
+ * Tests for {@link SparseDistributedMatrix}.
+ */
+@GridCommonTest(group = "Distributed Models")
+public class SparseDistributedMatrixTest extends GridCommonAbstractTest {
+ /** Number of nodes in grid */
+ private static final int NODE_COUNT = 3;
+ /** Cache name. */
+ private static final String CACHE_NAME = "test-cache";
+ /** Precision. */
+ private static final double PRECISION = 0.0;
+ /** Grid instance. */
+ private Ignite ignite;
+ /** Matrix rows */
+ private final int rows = MathTestConstants.STORAGE_SIZE;
+ /** Matrix cols */
+ private final int cols = MathTestConstants.STORAGE_SIZE;
+ /** Matrix for tests */
+ private SparseDistributedMatrix cacheMatrix;
+
+ /**
+ * Default constructor.
+ */
+ public SparseDistributedMatrixTest() {
+ super(false);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void beforeTestsStarted() throws Exception {
+ for (int i = 1; i <= NODE_COUNT; i++)
+ startGrid(i);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTestsStopped() throws Exception {
+ stopAllGrids();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override protected void beforeTest() throws Exception {
+ ignite = grid(NODE_COUNT);
+
+ ignite.configuration().setPeerClassLoadingEnabled(true);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTest() throws Exception {
+ ignite.destroyCache(CACHE_NAME);
+
+ if (cacheMatrix != null) {
+ cacheMatrix.destroy();
+ cacheMatrix = null;
+ }
+ }
+
+ /** */
+ public void testGetSet() throws Exception {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ for (int i = 0; i < rows; i++) {
+ for (int j = 0; j < cols; j++) {
+ double v = Math.random();
+ cacheMatrix.set(i, j, v);
+
+ assert Double.compare(v, cacheMatrix.get(i, j)) == 0;
+ }
+ }
+ }
+
+ /** */
+ public void testExternalize() throws IOException, ClassNotFoundException {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ cacheMatrix.set(1, 1, 1.0);
+
+ ByteArrayOutputStream byteArrOutputStream = new ByteArrayOutputStream();
+ ObjectOutputStream objOutputStream = new ObjectOutputStream(byteArrOutputStream);
+
+ objOutputStream.writeObject(cacheMatrix);
+
+ ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(byteArrOutputStream.toByteArray());
+ ObjectInputStream objInputStream = new ObjectInputStream(byteArrInputStream);
+
+ SparseDistributedMatrix objRestored = (SparseDistributedMatrix)objInputStream.readObject();
+
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, cacheMatrix.equals(objRestored));
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, objRestored.get(1, 1), 1.0, 0.0);
+ }
+
+ /** Test simple math. */
+ public void testMath() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+ initMtx(cacheMatrix);
+
+ cacheMatrix.assign(2.0);
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ assertEquals(UNEXPECTED_VAL, 2.0, cacheMatrix.get(i, j), PRECISION);
+
+ cacheMatrix.plus(3.0);
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ assertEquals(UNEXPECTED_VAL, 5.0, cacheMatrix.get(i, j), PRECISION);
+
+ cacheMatrix.times(2.0);
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ assertEquals(UNEXPECTED_VAL, 10.0, cacheMatrix.get(i, j), PRECISION);
+
+ cacheMatrix.divide(10.0);
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ assertEquals(UNEXPECTED_VAL, 1.0, cacheMatrix.get(i, j), PRECISION);
+
+ assertEquals(UNEXPECTED_VAL, cacheMatrix.rowSize() * cacheMatrix.columnSize(), cacheMatrix.sum(), PRECISION);
+ }
+
+ /** */
+ public void testMinMax() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ cacheMatrix.set(i, j, i * cols + j + 1);
+
+ assertEquals(UNEXPECTED_VAL, 1.0, cacheMatrix.minValue(), PRECISION);
+ assertEquals(UNEXPECTED_VAL, rows * cols, cacheMatrix.maxValue(), PRECISION);
+
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ cacheMatrix.set(i, j, -1.0 * (i * cols + j + 1));
+
+ assertEquals(UNEXPECTED_VAL, -rows * cols, cacheMatrix.minValue(), PRECISION);
+ assertEquals(UNEXPECTED_VAL, -1.0, cacheMatrix.maxValue(), PRECISION);
+
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ cacheMatrix.set(i, j, i * cols + j);
+
+ assertEquals(UNEXPECTED_VAL, 1.0, cacheMatrix.minValue(), PRECISION);
+ assertEquals(UNEXPECTED_VAL, rows * cols - 1.0, cacheMatrix.maxValue(), PRECISION);
+ }
+
+ /** */
+ public void testMap() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+ initMtx(cacheMatrix);
+
+ cacheMatrix.map(i -> 100.0);
+ for (int i = 0; i < cacheMatrix.rowSize(); i++)
+ for (int j = 0; j < cacheMatrix.columnSize(); j++)
+ assertEquals(UNEXPECTED_VAL, 100.0, cacheMatrix.get(i, j), PRECISION);
+ }
+
+ /** */
+ public void testCopy() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ try {
+ cacheMatrix.copy();
+ fail("UnsupportedOperationException expected.");
+ }
+ catch (UnsupportedOperationException e) {
+ return;
+ }
+ fail("UnsupportedOperationException expected.");
+ }
+
+ /** */
+ public void testLike() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ try {
+ cacheMatrix.like(1, 1);
+ fail("UnsupportedOperationException expected.");
+ }
+ catch (UnsupportedOperationException e) {
+ return;
+ }
+ fail("UnsupportedOperationException expected.");
+ }
+
+ /** */
+ public void testLikeVector() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ try {
+ cacheMatrix.likeVector(1);
+ fail("UnsupportedOperationException expected.");
+ }
+ catch (UnsupportedOperationException e) {
+ return;
+ }
+ fail("UnsupportedOperationException expected.");
+ }
+
+ /** */
+ private void initMtx(Matrix m) {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ m.set(i, j, 1.0);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java
new file mode 100644
index 0000000..fc675c1
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java
@@ -0,0 +1,53 @@
+/*
+ * 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.matrix;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class SparseLocalOnHeapMatrixConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new SparseLocalOnHeapMatrix(0, 1),
+ "invalid row parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new SparseLocalOnHeapMatrix(1, 0),
+ "invalid col parameter");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ assertEquals("Expected number of rows.", 1,
+ new SparseLocalOnHeapMatrix(1, 2).rowSize());
+
+ assertEquals("Expected number of cols, int parameters.", 1,
+ new SparseLocalOnHeapMatrix(2, 1).columnSize());
+
+ SparseLocalOnHeapMatrix m = new SparseLocalOnHeapMatrix(1, 1);
+ //noinspection EqualsWithItself
+ assertTrue("Matrix is expected to be equal to self.", m.equals(m));
+ //noinspection ObjectEqualsNull
+ assertFalse("Matrix is expected to be not equal to null.", m.equals(null));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java
new file mode 100644
index 0000000..5eacfea
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java
@@ -0,0 +1,87 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests for {@link TransposedMatrixView}.
+ */
+public class TransposedMatrixViewTest extends ExternalizeTest<TransposedMatrixView> {
+ /** */
+ private static final String UNEXPECTED_VALUE = "Unexpected value";
+ /** */
+ private TransposedMatrixView testMatrix;
+ /** */
+ private DenseLocalOnHeapMatrix parent;
+
+ /** */
+ @Before
+ public void setup() {
+ parent = new DenseLocalOnHeapMatrix(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
+ fillMatrix(parent);
+ testMatrix = new TransposedMatrixView(parent);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void externalizeTest() {
+ externalizeTest(testMatrix);
+ }
+
+ /** */
+ @Test
+ public void testView() {
+ assertEquals(UNEXPECTED_VALUE, parent.rowSize(), testMatrix.columnSize());
+ assertEquals(UNEXPECTED_VALUE, parent.columnSize(), testMatrix.rowSize());
+
+ for (int i = 0; i < parent.rowSize(); i++)
+ for (int j = 0; j < parent.columnSize(); j++)
+ assertEquals(UNEXPECTED_VALUE, parent.get(i, j), testMatrix.get(j, i), 0d);
+ }
+
+ /** */
+ @Test
+ public void testNullParams() {
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new TransposedMatrixView(null), "Null Matrix parameter");
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void testLike() {
+ testMatrix.like(0, 0);
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void testLikeVector() {
+ testMatrix.likeVector(0);
+ }
+
+ /** */
+ private void fillMatrix(DenseLocalOnHeapMatrix mtx) {
+ for (int i = 0; i < mtx.rowSize(); i++)
+ for (int j = 0; j < mtx.columnSize(); j++)
+ mtx.setX(i, j, i * mtx.rowSize() + j);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java
new file mode 100644
index 0000000..817dd49
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java
@@ -0,0 +1,63 @@
+/*
+ * 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.storage.matrix;
+
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests for {@link ArrayMatrixStorage}.
+ */
+public class MatrixArrayStorageTest extends MatrixBaseStorageTest<ArrayMatrixStorage> {
+ /** {@inheritDoc} */
+ @Override public void setUp() {
+ storage = new ArrayMatrixStorage(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void isSequentialAccess() throws Exception {
+ assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isSequentialAccess());
+ }
+
+ /** */
+ @Test
+ public void isDense() throws Exception {
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isDense());
+ }
+
+ /** */
+ @Test
+ public void isArrayBased() throws Exception {
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isArrayBased());
+ }
+
+ /** */
+ @Test
+ public void data() throws Exception {
+ double[][] data = storage.data();
+ assertNotNull(MathTestConstants.NULL_VAL, data);
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, data.length == MathTestConstants.STORAGE_SIZE);
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, data[0].length == MathTestConstants.STORAGE_SIZE);
+ }
+
+}
[13/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java
deleted file mode 100644
index 5a46218..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java
+++ /dev/null
@@ -1,655 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.storage.vector.FunctionVectorStorage;
-import org.jetbrains.annotations.NotNull;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-/** */
-class VectorImplementationsFixtures {
- /** */
- private static final List<Supplier<Iterable<Vector>>> suppliers = Arrays.asList(
- (Supplier<Iterable<Vector>>)DenseLocalOnHeapVectorFixture::new,
- (Supplier<Iterable<Vector>>)DenseLocalOffHeapVectorFixture::new,
- (Supplier<Iterable<Vector>>)SparseLocalVectorFixture::new,
- (Supplier<Iterable<Vector>>)RandomVectorFixture::new,
- (Supplier<Iterable<Vector>>)ConstantVectorFixture::new,
- (Supplier<Iterable<Vector>>)DelegatingVectorFixture::new,
- (Supplier<Iterable<Vector>>)FunctionVectorFixture::new,
- (Supplier<Iterable<Vector>>)SingleElementVectorFixture::new,
- (Supplier<Iterable<Vector>>)PivotedVectorViewFixture::new,
- (Supplier<Iterable<Vector>>)SingleElementVectorViewFixture::new,
- (Supplier<Iterable<Vector>>)MatrixVectorViewFixture::new,
- (Supplier<Iterable<Vector>>)SparseLocalOffHeapVectorFixture::new
- );
-
- /** */
- void consumeSampleVectors(Consumer<Integer> paramsConsumer, BiConsumer<Vector, String> consumer) {
- for (Supplier<Iterable<Vector>> fixtureSupplier : VectorImplementationsFixtures.suppliers) {
- final Iterable<Vector> fixture = fixtureSupplier.get();
-
- for (Vector v : fixture) {
- if (paramsConsumer != null)
- paramsConsumer.accept(v.size());
-
- consumer.accept(v, fixture.toString());
- }
- }
- }
-
- /** */
- void selfTest() {
- new VectorSizesExtraIterator<>("VectorSizesExtraIterator test",
- (size, shallowCp) -> new DenseLocalOnHeapVector(new double[size], shallowCp),
- null, "shallow copy", new Boolean[] {false, true, null}).selfTest();
-
- new VectorSizesIterator("VectorSizesIterator test", DenseLocalOffHeapVector::new, null).selfTest();
- }
-
- /** */
- private static class DenseLocalOnHeapVectorFixture extends VectorSizesExtraFixture<Boolean> {
- /** */
- DenseLocalOnHeapVectorFixture() {
- super("DenseLocalOnHeapVector",
- (size, shallowCp) -> new DenseLocalOnHeapVector(new double[size], shallowCp),
- "shallow copy", new Boolean[] {false, true, null});
- }
- }
-
- /** */
- private static class DenseLocalOffHeapVectorFixture extends VectorSizesFixture {
- /** */
- DenseLocalOffHeapVectorFixture() {
- super("DenseLocalOffHeapVector", DenseLocalOffHeapVector::new);
- }
- }
-
- /** */
- private static class SparseLocalVectorFixture extends VectorSizesExtraFixture<Integer> {
- /** */
- SparseLocalVectorFixture() {
- super("SparseLocalVector", SparseLocalVector::new, "access mode",
- new Integer[] {StorageConstants.SEQUENTIAL_ACCESS_MODE, StorageConstants.RANDOM_ACCESS_MODE, null});
- }
- }
-
- /** */
- private static class RandomVectorFixture extends VectorSizesFixture {
- /** */
- RandomVectorFixture() {
- super("RandomVector", RandomVector::new);
- }
- }
-
- /** */
- private static class ConstantVectorFixture extends VectorSizesExtraFixture<Double> {
- /** */
- ConstantVectorFixture() {
- super("ConstantVector", ConstantVector::new,
- "value", new Double[] {-1.0, 0.0, 0.5, 1.0, 2.0, null});
- }
- }
-
- /** */
- private static class FunctionVectorFixture extends VectorSizesExtraFixture<Double> {
- /** */
- FunctionVectorFixture() {
- super("FunctionVector",
- (size, scale) -> new FunctionVectorForTest(new double[size], scale),
- "scale", new Double[] {0.5, 1.0, 2.0, null});
- }
- }
-
- /** */
- private static class SingleElementVectorFixture implements Iterable<Vector> {
- /** */
- private final Supplier<TwoParamsIterator<Integer, Double>> iter;
-
- /** */
- private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
-
- /** */
- SingleElementVectorFixture() {
- iter = () -> new TwoParamsIterator<Integer, Double>("SingleElementVector",
- null, ctxDescrHolder::set,
- "size", new Integer[] {1, null},
- "value", new Double[] {-1.0, 0.0, 0.5, 1.0, 2.0, null}) {
-
- /** {@inheritDoc} */
- @Override BiFunction<Integer, Double, Vector> ctor() {
- return (size, value) -> new SingleElementVector(size, 0, value);
- }
- };
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Vector> iterator() {
- return iter.get();//(
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return ctxDescrHolder.get();
- }
- }
-
- /** */
- private static class PivotedVectorViewFixture extends VectorSizesFixture {
- /** */
- PivotedVectorViewFixture() {
- super("PivotedVectorView", PivotedVectorViewFixture::pivotedVectorView);
- }
-
- /** */
- private static PivotedVectorView pivotedVectorView(int size) {
- final DenseLocalOnHeapVector vec = new DenseLocalOnHeapVector(size);
-
- final int[] pivot = new int[size];
-
- for (int idx = 0; idx < size; idx++)
- pivot[idx] = size - 1 - idx;
-
- PivotedVectorView tmp = new PivotedVectorView(vec, pivot);
-
- final int[] unpivot = new int[size];
-
- for (int idx = 0; idx < size; idx++)
- unpivot[idx] = tmp.unpivot(idx);
-
- final int[] idxRecovery = new int[size];
-
- for (int idx = 0; idx < size; idx++)
- idxRecovery[idx] = idx;
-
- return new PivotedVectorView(new PivotedVectorView(tmp, unpivot), idxRecovery);
- }
- }
-
- /** */
- private static class SingleElementVectorViewFixture implements Iterable<Vector> {
- /** */
- private final Supplier<TwoParamsIterator<Integer, Double>> iter;
-
- /** */
- private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
-
- /** */
- SingleElementVectorViewFixture() {
- iter = () -> new TwoParamsIterator<Integer, Double>("SingleElementVectorView",
- null, ctxDescrHolder::set,
- "size", new Integer[] {1, null},
- "value", new Double[] {-1.0, 0.0, 0.5, 1.0, 2.0, null}) {
-
- /** {@inheritDoc} */
- @Override BiFunction<Integer, Double, Vector> ctor() {
- return (size, value) -> new SingleElementVectorView(new SingleElementVector(size, 0, value), 0);
- }
- };
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Vector> iterator() {
- return iter.get();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return ctxDescrHolder.get();
- }
- }
-
- /** */
- private static class MatrixVectorViewFixture extends VectorSizesExtraFixture<Integer> {
- /** */
- MatrixVectorViewFixture() {
- super("MatrixVectorView",
- MatrixVectorViewFixture::newView,
- "stride kind", new Integer[] {0, 1, 2, null});
- }
-
- /** */
- private static Vector newView(int size, int strideKind) {
- final Matrix parent = new DenseLocalOnHeapMatrix(size, size);
-
- return new MatrixVectorView(parent, 0, 0, strideKind != 1 ? 1 : 0, strideKind != 0 ? 1 : 0);
- }
- }
-
- /** */
- private static class VectorSizesExtraFixture<T> implements Iterable<Vector> {
- /** */
- private final Supplier<VectorSizesExtraIterator<T>> iter;
-
- /** */
- private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
-
- /** */
- VectorSizesExtraFixture(String vectorKind, BiFunction<Integer, T, Vector> ctor, String extraParamName,
- T[] extras) {
- iter = () -> new VectorSizesExtraIterator<>(vectorKind, ctor, ctxDescrHolder::set, extraParamName, extras);
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Vector> iterator() {
- return iter.get();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return ctxDescrHolder.get();
- }
- }
-
- /** */
- private static abstract class VectorSizesFixture implements Iterable<Vector> {
- /** */
- private final Supplier<VectorSizesIterator> iter;
-
- /** */
- private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
-
- /** */
- VectorSizesFixture(String vectorKind, Function<Integer, Vector> ctor) {
- iter = () -> new VectorSizesIterator(vectorKind, ctor, ctxDescrHolder::set);
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Vector> iterator() {
- return iter.get();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return ctxDescrHolder.get();
- }
- }
-
- /** */
- private static class VectorSizesExtraIterator<T> extends VectorSizesIterator {
- /** */
- private final T[] extras;
- /** */
- private int extraIdx = 0;
- /** */
- private final BiFunction<Integer, T, Vector> ctor;
- /** */
- private final String extraParamName;
-
- /**
- * @param vectorKind Descriptive name to use for context logging.
- * @param ctor Constructor for objects to iterate over.
- * @param ctxDescrConsumer Context logging consumer.
- * @param extraParamName Name of extra parameter to iterate over.
- * @param extras Array of extra parameter values to iterate over.
- */
- VectorSizesExtraIterator(String vectorKind, BiFunction<Integer, T, Vector> ctor,
- Consumer<String> ctxDescrConsumer, String extraParamName, T[] extras) {
- super(vectorKind, null, ctxDescrConsumer);
-
- this.ctor = ctor;
- this.extraParamName = extraParamName;
- this.extras = extras;
- }
-
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return super.hasNext() && hasNextExtra(extraIdx);
- }
-
- /** {@inheritDoc} */
- @Override void nextIdx() {
- assert extras[extraIdx] != null
- : "Index(es) out of bound at " + VectorSizesExtraIterator.this;
-
- if (hasNextExtra(extraIdx + 1)) {
- extraIdx++;
-
- return;
- }
-
- extraIdx = 0;
-
- super.nextIdx();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return "{" + super.toString() +
- ", " + extraParamName + "=" + extras[extraIdx] +
- '}';
- }
-
- /** {@inheritDoc} */
- @Override BiFunction<Integer, Integer, Vector> ctor() {
- return (size, delta) -> ctor.apply(size + delta, extras[extraIdx]);
- }
-
- /** */
- void selfTest() {
- final Set<Integer> extraIdxs = new HashSet<>();
-
- int cnt = 0;
-
- while (hasNext()) {
- assertNotNull("Expect not null vector at " + this, next());
-
- if (extras[extraIdx] != null)
- extraIdxs.add(extraIdx);
-
- cnt++;
- }
-
- assertEquals("Extra param tested", extraIdxs.size(), extras.length - 1);
-
- assertEquals("Combinations tested mismatch.",
- 7 * 3 * (extras.length - 1), cnt);
- }
-
- /** */
- private boolean hasNextExtra(int idx) {
- return extras[idx] != null;
- }
- }
-
- /** */
- private static class VectorSizesIterator extends TwoParamsIterator<Integer, Integer> {
- /** */
- private final Function<Integer, Vector> ctor;
-
- /** */
- VectorSizesIterator(String vectorKind, Function<Integer, Vector> ctor, Consumer<String> ctxDescrConsumer) {
- super(vectorKind, null, ctxDescrConsumer,
- "size", new Integer[] {2, 4, 8, 16, 32, 64, 128, null},
- "size delta", new Integer[] {-1, 0, 1, null});
-
- this.ctor = ctor;
- }
-
- /** {@inheritDoc} */
- @Override BiFunction<Integer, Integer, Vector> ctor() {
- return (size, delta) -> ctor.apply(size + delta);
- }
- }
-
- /** */
- private static class TwoParamsIterator<T, U> implements Iterator<Vector> {
- /** */
- private final T params1[];
-
- /** */
- private final U params2[];
-
- /** */
- private final String vectorKind;
-
- /** */
- private final String param1Name;
-
- /** */
- private final String param2Name;
-
- /** */
- private final BiFunction<T, U, Vector> ctor;
-
- /** */
- private final Consumer<String> ctxDescrConsumer;
-
- /** */
- private int param1Idx = 0;
-
- /** */
- private int param2Idx = 0;
-
- /** */
- TwoParamsIterator(String vectorKind, BiFunction<T, U, Vector> ctor,
- Consumer<String> ctxDescrConsumer, String param1Name, T[] params1, String param2Name, U[] params2) {
- this.param1Name = param1Name;
- this.params1 = params1;
-
- this.param2Name = param2Name;
- this.params2 = params2;
-
- this.vectorKind = vectorKind;
-
- this.ctor = ctor;
-
- this.ctxDescrConsumer = ctxDescrConsumer;
- }
-
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return hasNextParam1(param1Idx) && hasNextParam2(param2Idx);
- }
-
- /** {@inheritDoc} */
- @Override public Vector next() {
- if (!hasNext())
- throw new NoSuchElementException(TwoParamsIterator.this.toString());
-
- if (ctxDescrConsumer != null)
- ctxDescrConsumer.accept(toString());
-
- Vector res = ctor().apply(params1[param1Idx], params2[param2Idx]);
-
- nextIdx();
-
- return res;
- }
-
- /** */
- void selfTest() {
- final Set<Integer> sizeIdxs = new HashSet<>(), deltaIdxs = new HashSet<>();
-
- int cnt = 0;
-
- while (hasNext()) {
- assertNotNull("Expect not null vector at " + this, next());
-
- if (params1[param1Idx] != null)
- sizeIdxs.add(param1Idx);
-
- if (params2[param2Idx] != null)
- deltaIdxs.add(param2Idx);
-
- cnt++;
- }
-
- assertEquals("Sizes tested mismatch.", sizeIdxs.size(), params1.length - 1);
-
- assertEquals("Deltas tested", deltaIdxs.size(), params2.length - 1);
-
- assertEquals("Combinations tested mismatch.",
- (params1.length - 1) * (params2.length - 1), cnt);
- }
-
- /** IMPL NOTE override in subclasses if needed */
- void nextIdx() {
- assert params1[param1Idx] != null && params2[param2Idx] != null
- : "Index(es) out of bound at " + TwoParamsIterator.this;
-
- if (hasNextParam2(param2Idx + 1)) {
- param2Idx++;
-
- return;
- }
-
- param2Idx = 0;
-
- param1Idx++;
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return vectorKind + "{" + param1Name + "=" + params1[param1Idx] +
- ", " + param2Name + "=" + params2[param2Idx] +
- '}';
- }
-
- /** IMPL NOTE override in subclasses if needed */
- BiFunction<T, U, Vector> ctor() {
- return ctor;
- }
-
- /** */
- private boolean hasNextParam1(int idx) {
- return params1[idx] != null;
- }
-
- /** */
- private boolean hasNextParam2(int idx) {
- return params2[idx] != null;
- }
- }
-
- /** Delegating vector with dense local onheap vector */
- private static class DelegatingVectorFixture implements Iterable<Vector> {
-
- /** */
- private final Supplier<VectorSizesExtraIterator<Boolean>> iter;
-
- /** */
- private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
-
- /** */
- DelegatingVectorFixture() {
- iter = () -> new VectorSizesExtraIterator<>("DelegatingVector with DenseLocalOnHeapVector",
- (size, shallowCp) -> new DelegatingVector(new DenseLocalOnHeapVector(new double[size], shallowCp)),
- ctxDescrHolder::set, "shallow copy", new Boolean[] {false, true, null});
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Vector> iterator() {
- return iter.get();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
- return ctxDescrHolder.get();
- }
- }
-
- /** Subclass tweaked for serialization */
- private static class FunctionVectorForTest extends FunctionVector {
- /** */
- double[] arr;
-
- /** */
- double scale;
-
- /** */
- public FunctionVectorForTest() {
- // No-op.
- }
-
- /** */
- FunctionVectorForTest(double[] arr, double scale) {
- super(arr.length, idx -> arr[idx] * scale, (idx, value) -> arr[idx] = value / scale);
-
- this.arr = arr;
-
- this.scale = scale;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeObject(arr);
-
- out.writeDouble(scale);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- arr = (double[])in.readObject();
-
- scale = in.readDouble();
-
- setStorage(new FunctionVectorStorage(arr.length, idx -> arr[idx] * scale, (idx, value) -> arr[idx] = value / scale));
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + Double.hashCode(scale);
- res = res * 37 + Integer.hashCode(getStorage().size());
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- FunctionVectorForTest that = (FunctionVectorForTest)o;
-
- return new Double(scale).equals(that.scale)
- && (arr != null ? Arrays.equals(arr, that.arr) : that.arr == null);
- }
- }
-
- /** */
- private static class SparseLocalOffHeapVectorFixture extends VectorSizesFixture {
-
- /** */
- SparseLocalOffHeapVectorFixture() {
- super("SparseLocalOffHeapVector", SparseLocalOffHeapVector::new);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java
deleted file mode 100644
index 0e61513..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsTest.java
+++ /dev/null
@@ -1,860 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import org.apache.ignite.IgniteException;
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.CardinalityException;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/** See also: {@link AbstractVectorTest} and {@link VectorToMatrixTest}. */
-public class VectorImplementationsTest { // todo split this to smaller cohesive test classes
- /** */
- @Test
- public void vectorImplementationsFixturesTest() {
- new VectorImplementationsFixtures().selfTest();
- }
-
- /** */
- @Test
- public void setGetTest() {
- consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
- vec.set(idx, val);
-
- return val;
- }));
- }
-
- /** */
- @Test
- public void setXTest() {
- consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
- vec.setX(idx, val);
-
- return val;
- }));
- }
-
- /** */
- @Test
- public void incrementTest() {
- consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
- double old = vec.get(idx);
-
- vec.increment(idx, val);
-
- return old + val;
- }));
- }
-
- /** */
- @Test
- public void incrementXTest() {
- consumeSampleVectors((v, desc) -> mutateAtIdxTest(v, desc, (vec, idx, val) -> {
- double old = vec.getX(idx);
-
- vec.incrementX(idx, val);
-
- return old + val;
- }));
- }
-
- /** */
- @Test
- public void operateXOutOfBoundsTest() {
- consumeSampleVectors((v, desc) -> {
- if (v instanceof DenseLocalOffHeapVector || v instanceof SparseLocalVector || v instanceof SparseLocalOffHeapVector)
- return; // todo find out if it's OK to skip by instances here
-
- boolean expECaught = false;
-
- try {
- v.getX(-1);
- }
- catch (ArrayIndexOutOfBoundsException | IgniteException e) {
- expECaught = true;
- }
-
- if (!getXOutOfBoundsOK(v))
- assertTrue("Expect exception at negative index getX in " + desc, expECaught);
-
- expECaught = false;
-
- try {
- v.setX(-1, 0);
- }
- catch (ArrayIndexOutOfBoundsException | IgniteException e) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at negative index setX in " + desc, expECaught);
-
- expECaught = false;
-
- try {
- v.incrementX(-1, 1);
- }
- catch (ArrayIndexOutOfBoundsException | IgniteException e) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at negative index incrementX in " + desc, expECaught);
-
- expECaught = false;
-
- try {
- v.getX(v.size());
- }
- catch (ArrayIndexOutOfBoundsException | IgniteException e) {
- expECaught = true;
- }
-
- if (!getXOutOfBoundsOK(v))
- assertTrue("Expect exception at too large index getX in " + desc, expECaught);
-
- expECaught = false;
-
- try {
- v.setX(v.size(), 1);
- }
- catch (ArrayIndexOutOfBoundsException | IgniteException e) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too large index setX in " + desc, expECaught);
-
- expECaught = false;
-
- try {
- v.incrementX(v.size(), 1);
- }
- catch (ArrayIndexOutOfBoundsException | IgniteException e) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too large index incrementX in " + desc, expECaught);
- });
- }
-
- /** */
- @Test
- public void sizeTest() {
- final AtomicReference<Integer> expSize = new AtomicReference<>(0);
-
- consumeSampleVectors(
- expSize::set,
- (v, desc) -> assertEquals("Expected size for " + desc,
- (int)expSize.get(), v.size())
- );
- }
-
- /** */
- @Test
- public void getElementTest() {
- consumeSampleVectors((v, desc) -> new ElementsChecker(v, desc).assertCloseEnough(v));
- }
-
- /** */
- @Test
- public void copyTest() {
- consumeSampleVectors((v, desc) -> new ElementsChecker(v, desc).assertCloseEnough(v.copy()));
- }
-
- /** */
- @Test
- public void divideTest() {
- operationTest((val, operand) -> val / operand, Vector::divide);
- }
-
- /** */
- @Test
- public void likeTest() {
- for (int card : new int[] {1, 2, 4, 8, 16, 32, 64, 128})
- consumeSampleVectors((v, desc) -> {
- Class<? extends Vector> expType = expLikeType(v);
-
- if (expType == null) {
- try {
- v.like(card);
- }
- catch (UnsupportedOperationException uoe) {
- return;
- }
-
- fail("Expected exception wasn't caught for " + desc);
-
- return;
- }
-
- Vector vLike = v.like(card);
-
- assertNotNull("Expect non-null like vector for " + expType.getSimpleName() + " in " + desc, vLike);
- assertEquals("Expect size equal to cardinality at " + desc, card, vLike.size());
-
- Class<? extends Vector> actualType = vLike.getClass();
-
- assertTrue("Actual vector type " + actualType.getSimpleName()
- + " should be assignable from expected type " + expType.getSimpleName() + " in " + desc,
- actualType.isAssignableFrom(expType));
- });
- }
-
- /** */
- @Test
- public void minusTest() {
- operationVectorTest((operand1, operand2) -> operand1 - operand2, Vector::minus);
- }
-
- /** */
- @Test
- public void plusVectorTest() {
- operationVectorTest((operand1, operand2) -> operand1 + operand2, Vector::plus);
- }
-
- /** */
- @Test
- public void plusDoubleTest() {
- operationTest((val, operand) -> val + operand, Vector::plus);
- }
-
- /** */
- @Test
- public void timesVectorTest() {
- operationVectorTest((operand1, operand2) -> operand1 * operand2, Vector::times);
- }
-
- /** */
- @Test
- public void timesDoubleTest() {
- operationTest((val, operand) -> val * operand, Vector::times);
- }
-
- /** */
- @Test
- public void viewPartTest() {
- consumeSampleVectors((v, desc) -> {
- final int size = v.size();
- final double[] ref = new double[size];
- final int delta = size > 32 ? 3 : 1; // IMPL NOTE this is for faster test execution
-
- final ElementsChecker checker = new ElementsChecker(v, ref, desc);
-
- for (int off = 0; off < size; off += delta)
- for (int len = 1; len < size - off; len += delta)
- checker.assertCloseEnough(v.viewPart(off, len), Arrays.copyOfRange(ref, off, off + len));
- });
- }
-
- /** */
- @Test
- public void sumTest() {
- toDoubleTest(
- ref -> Arrays.stream(ref).sum(),
- Vector::sum);
- }
-
- /** */
- @Test
- public void minValueTest() {
- toDoubleTest(
- ref -> Arrays.stream(ref).min().getAsDouble(),
- Vector::minValue);
- }
-
- /** */
- @Test
- public void maxValueTest() {
- toDoubleTest(
- ref -> Arrays.stream(ref).max().getAsDouble(),
- Vector::maxValue);
- }
-
- /** */
- @Test
- public void sortTest() {
- consumeSampleVectors((v, desc) -> {
- if (readOnly(v) || !v.isArrayBased()) {
- boolean expECaught = false;
-
- try {
- v.sort();
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expected exception was not caught for sort in " + desc, expECaught);
-
- return;
- }
-
- final int size = v.size();
- final double[] ref = new double[size];
-
- new ElementsChecker(v, ref, desc).assertCloseEnough(v.sort(), Arrays.stream(ref).sorted().toArray());
- });
- }
-
- /** */
- @Test
- public void metaAttributesTest() {
- consumeSampleVectors((v, desc) -> {
- assertNotNull("Null meta storage in " + desc, v.getMetaStorage());
-
- final String key = "test key";
- final String val = "test value";
- final String details = "key [" + key + "] for " + desc;
-
- v.setAttribute(key, val);
- assertTrue("Expect to have meta attribute for " + details, v.hasAttribute(key));
- assertEquals("Unexpected meta attribute value for " + details, val, v.getAttribute(key));
-
- v.removeAttribute(key);
- assertFalse("Expect not to have meta attribute for " + details, v.hasAttribute(key));
- assertNull("Unexpected meta attribute value for " + details, v.getAttribute(key));
- });
- }
-
- /** */
- @Test
- public void assignDoubleTest() {
- consumeSampleVectors((v, desc) -> {
- if (readOnly(v))
- return;
-
- for (double val : new double[] {0, -1, 0, 1}) {
- v.assign(val);
-
- for (int idx = 0; idx < v.size(); idx++) {
- final Metric metric = new Metric(val, v.get(idx));
-
- assertTrue("Not close enough at index " + idx + ", val " + val + ", " + metric
- + ", " + desc, metric.closeEnough());
- }
- }
- });
- }
-
- /** */
- @Test
- public void assignDoubleArrTest() {
- consumeSampleVectors((v, desc) -> {
- if (readOnly(v))
- return;
-
- final int size = v.size();
- final double[] ref = new double[size];
-
- final ElementsChecker checker = new ElementsChecker(v, ref, desc);
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = -ref[idx];
-
- v.assign(ref);
-
- checker.assertCloseEnough(v, ref);
-
- assignDoubleArrWrongCardinality(v, desc);
- });
- }
-
- /** */
- @Test
- public void assignVectorTest() {
- consumeSampleVectors((v, desc) -> {
- if (readOnly(v))
- return;
-
- final int size = v.size();
- final double[] ref = new double[size];
-
- final ElementsChecker checker = new ElementsChecker(v, ref, desc);
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = -ref[idx];
-
- v.assign(new DenseLocalOnHeapVector(ref));
-
- checker.assertCloseEnough(v, ref);
-
- assignVectorWrongCardinality(v, desc);
- });
- }
-
- /** */
- @Test
- public void assignFunctionTest() {
- consumeSampleVectors((v, desc) -> {
- if (readOnly(v))
- return;
-
- final int size = v.size();
- final double[] ref = new double[size];
-
- final ElementsChecker checker = new ElementsChecker(v, ref, desc);
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = -ref[idx];
-
- v.assign((idx) -> ref[idx]);
-
- checker.assertCloseEnough(v, ref);
- });
- }
-
- /** */
- @Test
- public void minElementTest() {
- consumeSampleVectors((v, desc) -> {
- final ElementsChecker checker = new ElementsChecker(v, desc);
-
- final Vector.Element minE = v.minElement();
-
- final int minEIdx = minE.index();
-
- assertTrue("Unexpected index from minElement " + minEIdx + ", " + desc,
- minEIdx >= 0 && minEIdx < v.size());
-
- final Metric metric = new Metric(minE.get(), v.minValue());
-
- assertTrue("Not close enough minElement at index " + minEIdx + ", " + metric
- + ", " + desc, metric.closeEnough());
-
- checker.assertNewMinElement(v);
- });
- }
-
- /** */
- @Test
- public void maxElementTest() {
- consumeSampleVectors((v, desc) -> {
- final ElementsChecker checker = new ElementsChecker(v, desc);
-
- final Vector.Element maxE = v.maxElement();
-
- final int minEIdx = maxE.index();
-
- assertTrue("Unexpected index from minElement " + minEIdx + ", " + desc,
- minEIdx >= 0 && minEIdx < v.size());
-
- final Metric metric = new Metric(maxE.get(), v.maxValue());
-
- assertTrue("Not close enough maxElement at index " + minEIdx + ", " + metric
- + ", " + desc, metric.closeEnough());
-
- checker.assertNewMaxElement(v);
- });
- }
-
- /** */
- @Test
- public void externalizeTest() {
- (new ExternalizeTest<Vector>() {
- /** {@inheritDoc} */
- @Override public void externalizeTest() {
- consumeSampleVectors((v, desc) -> {
- if (v instanceof SparseLocalOffHeapVector)
- return; //TODO: wait till SparseLocalOffHeapVector externalization support.
-
- externalizeTest(v);
- });
- }
- }).externalizeTest();
- }
-
- /** */
- @Test
- public void hashCodeTest() {
- consumeSampleVectors((v, desc) -> assertTrue("Zero hash code for " + desc, v.hashCode() != 0));
- }
-
- /** */
- private boolean getXOutOfBoundsOK(Vector v) {
- // todo find out if this is indeed OK
- return v instanceof RandomVector || v instanceof ConstantVector
- || v instanceof SingleElementVector || v instanceof SingleElementVectorView;
- }
-
- /** */
- private void mutateAtIdxTest(Vector v, String desc, MutateAtIdx operation) {
- if (readOnly(v)) {
- if (v.size() < 1)
- return;
-
- boolean expECaught = false;
-
- try {
- operation.apply(v, 0, 1);
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at attempt to mutate element in " + desc, expECaught);
-
- return;
- }
-
- for (double val : new double[] {0, -1, 0, 1})
- for (int idx = 0; idx < v.size(); idx++) {
- double exp = operation.apply(v, idx, val);
-
- final Metric metric = new Metric(exp, v.get(idx));
-
- assertTrue("Not close enough at index " + idx + ", val " + val + ", " + metric
- + ", " + desc, metric.closeEnough());
- }
- }
-
- /** */
- private Class<? extends Vector> expLikeType(Vector v) {
- Class<? extends Vector> clazz = v.getClass();
-
- if (clazz.isAssignableFrom(PivotedVectorView.class) || clazz.isAssignableFrom(SingleElementVectorView.class))
- return null;
-
- if (clazz.isAssignableFrom(MatrixVectorView.class) || clazz.isAssignableFrom(DelegatingVector.class))
- return DenseLocalOnHeapVector.class; // IMPL NOTE per fixture
-
- return clazz;
- }
-
- /** */
- private void toDoubleTest(Function<double[], Double> calcRef, Function<Vector, Double> calcVec) {
- consumeSampleVectors((v, desc) -> {
- final int size = v.size();
- final double[] ref = new double[size];
-
- new ElementsChecker(v, ref, desc); // IMPL NOTE this initialises vector and reference array
-
- final Metric metric = new Metric(calcRef.apply(ref), calcVec.apply(v));
-
- assertTrue("Not close enough at " + desc
- + ", " + metric, metric.closeEnough());
- });
- }
-
- /** */
- private void operationVectorTest(BiFunction<Double, Double, Double> operation,
- BiFunction<Vector, Vector, Vector> vecOperation) {
- consumeSampleVectors((v, desc) -> {
- // TODO find out if more elaborate testing scenario is needed or it's okay as is.
- final int size = v.size();
- final double[] ref = new double[size];
-
- final ElementsChecker checker = new ElementsChecker(v, ref, desc);
- final Vector operand = v.copy();
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = operation.apply(ref[idx], ref[idx]);
-
- checker.assertCloseEnough(vecOperation.apply(v, operand), ref);
-
- assertWrongCardinality(v, desc, vecOperation);
- });
- }
-
- /** */
- private void assignDoubleArrWrongCardinality(Vector v, String desc) {
- boolean expECaught = false;
-
- try {
- v.assign(new double[v.size() + 1]);
- }
- catch (CardinalityException ce) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too large size in " + desc, expECaught);
-
- if (v.size() < 2)
- return;
-
- expECaught = false;
-
- try {
- v.assign(new double[v.size() - 1]);
- }
- catch (CardinalityException ce) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too small size in " + desc, expECaught);
- }
-
- /** */
- private void assignVectorWrongCardinality(Vector v, String desc) {
- boolean expECaught = false;
-
- try {
- v.assign(new DenseLocalOnHeapVector(v.size() + 1));
- }
- catch (CardinalityException ce) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too large size in " + desc, expECaught);
-
- if (v.size() < 2)
- return;
-
- expECaught = false;
-
- try {
- v.assign(new DenseLocalOnHeapVector(v.size() - 1));
- }
- catch (CardinalityException ce) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too small size in " + desc, expECaught);
- }
-
- /** */
- private void assertWrongCardinality(
- Vector v, String desc, BiFunction<Vector, Vector, Vector> vecOperation) {
- boolean expECaught = false;
-
- try {
- vecOperation.apply(v, new DenseLocalOnHeapVector(v.size() + 1));
- }
- catch (CardinalityException ce) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too large size in " + desc, expECaught);
-
- if (v.size() < 2)
- return;
-
- expECaught = false;
-
- try {
- vecOperation.apply(v, new DenseLocalOnHeapVector(v.size() - 1));
- }
- catch (CardinalityException ce) {
- expECaught = true;
- }
-
- assertTrue("Expect exception at too small size in " + desc, expECaught);
- }
-
- /** */
- private void operationTest(BiFunction<Double, Double, Double> operation,
- BiFunction<Vector, Double, Vector> vecOperation) {
- for (double val : new double[] {0, 0.1, 1, 2, 10})
- consumeSampleVectors((v, desc) -> {
- final int size = v.size();
- final double[] ref = new double[size];
-
- final ElementsChecker checker = new ElementsChecker(v, ref, "val " + val + ", " + desc);
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = operation.apply(ref[idx], val);
-
- checker.assertCloseEnough(vecOperation.apply(v, val), ref);
- });
- }
-
- /** */
- private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
- consumeSampleVectors(null, consumer);
- }
-
- /** */
- private void consumeSampleVectors(Consumer<Integer> paramsConsumer, BiConsumer<Vector, String> consumer) {
- new VectorImplementationsFixtures().consumeSampleVectors(paramsConsumer, consumer);
- }
-
- /** */
- private static boolean readOnly(Vector v) {
- return v instanceof RandomVector || v instanceof ConstantVector;
- }
-
- /** */
- private interface MutateAtIdx {
- /** */
- double apply(Vector v, int idx, double val);
- }
-
- /** */
- static class ElementsChecker {
- /** */
- private final String fixtureDesc;
-
- /** */
- private final double[] refReadOnly;
-
- /** */
- private final boolean nonNegative;
-
- /** */
- ElementsChecker(Vector v, double[] ref, String fixtureDesc, boolean nonNegative) {
- this.fixtureDesc = fixtureDesc;
-
- this.nonNegative = nonNegative;
-
- refReadOnly = readOnly(v) && ref == null ? new double[v.size()] : null;
-
- init(v, ref);
- }
-
- /** */
- ElementsChecker(Vector v, double[] ref, String fixtureDesc) {
- this(v, ref, fixtureDesc, false);
- }
-
- /** */
- ElementsChecker(Vector v, String fixtureDesc) {
- this(v, null, fixtureDesc);
- }
-
- /** */
- void assertCloseEnough(Vector obtained, double[] exp) {
- final int size = obtained.size();
-
- for (int i = 0; i < size; i++) {
- final Vector.Element e = obtained.getElement(i);
-
- if (refReadOnly != null && exp == null)
- exp = refReadOnly;
-
- final Metric metric = new Metric(exp == null ? generated(i) : exp[i], e.get());
-
- assertEquals("Unexpected vector index at " + fixtureDesc, i, e.index());
- assertTrue("Not close enough at index " + i + ", size " + size + ", " + metric
- + ", " + fixtureDesc, metric.closeEnough());
- }
- }
-
- /** */
- void assertCloseEnough(Vector obtained) {
- assertCloseEnough(obtained, null);
- }
-
- /** */
- void assertNewMinElement(Vector v) {
- if (readOnly(v))
- return;
-
- int exp = v.size() / 2;
-
- v.set(exp, -(v.size() * 2 + 1));
-
- assertEquals("Unexpected minElement index at " + fixtureDesc, exp, v.minElement().index());
- }
-
- /** */
- void assertNewMaxElement(Vector v) {
- if (readOnly(v))
- return;
-
- int exp = v.size() / 2;
-
- v.set(exp, v.size() * 2 + 1);
-
- assertEquals("Unexpected minElement index at " + fixtureDesc, exp, v.maxElement().index());
- }
-
- /** */
- private void init(Vector v, double[] ref) {
- if (readOnly(v)) {
- initReadonly(v, ref);
-
- return;
- }
-
- for (Vector.Element e : v.all()) {
- int idx = e.index();
-
- // IMPL NOTE introduce negative values because their absence
- // blocked catching an ugly bug in AbstractVector#kNorm
- int val = generated(idx);
-
- e.set(val);
-
- if (ref != null)
- ref[idx] = val;
- }
- }
-
- /** */
- private void initReadonly(Vector v, double[] ref) {
- if (refReadOnly != null)
- for (Vector.Element e : v.all())
- refReadOnly[e.index()] = e.get();
-
- if (ref != null)
- for (Vector.Element e : v.all())
- ref[e.index()] = e.get();
- }
-
- /** */
- private int generated(int idx) {
- return nonNegative || (idx & 1) == 0 ? idx : -idx;
- }
- }
-
- /** */
- static class Metric { // todo consider if softer tolerance (like say 0.1 or 0.01) would make sense here
- /** */
- private final double exp;
-
- /** */
- private final double obtained;
-
- /** **/
- Metric(double exp, double obtained) {
- this.exp = exp;
- this.obtained = obtained;
- }
-
- /** */
- boolean closeEnough() {
- return new Double(exp).equals(obtained) || closeEnoughToZero();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- return "Metric{" + "expected=" + exp +
- ", obtained=" + obtained +
- '}';
- }
-
- /** */
- private boolean closeEnoughToZero() {
- return (new Double(exp).equals(0.0) && new Double(obtained).equals(-0.0))
- || (new Double(exp).equals(-0.0) && new Double(obtained).equals(0.0));
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java
deleted file mode 100644
index 7a64c85..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorIterableTest.java
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-import java.util.Spliterator;
-import java.util.function.BiConsumer;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Test;
-
-import static java.util.Spliterator.ORDERED;
-import static java.util.Spliterator.SIZED;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/** */
-public class VectorIterableTest {
- /** */
- @Test
- public void allTest() {
- consumeSampleVectors(
- (v, desc) -> {
- int expIdx = 0;
-
- for (Vector.Element e : v.all()) {
- int actualIdx = e.index();
-
- assertEquals("Unexpected index for " + desc,
- expIdx, actualIdx);
-
- expIdx++;
- }
-
- assertEquals("Unexpected amount of elements for " + desc,
- expIdx, v.size());
- }
- );
- }
-
- /** */
- @Test
- public void allTestBound() {
- consumeSampleVectors(
- (v, desc) -> iteratorTestBound(v.all().iterator(), desc)
- );
- }
-
- /** */
- @Test
- public void nonZeroesTestBasic() {
- final int size = 5;
-
- final double[] nonZeroesOddData = new double[size], nonZeroesEvenData = new double[size];
-
- for (int idx = 0; idx < size; idx++) {
- final boolean odd = (idx & 1) == 1;
-
- nonZeroesOddData[idx] = odd ? 1 : 0;
-
- nonZeroesEvenData[idx] = odd ? 0 : 1;
- }
-
- assertTrue("Arrays failed to initialize.",
- !isZero(nonZeroesEvenData[0])
- && isZero(nonZeroesEvenData[1])
- && isZero(nonZeroesOddData[0])
- && !isZero(nonZeroesOddData[1]));
-
- final Vector nonZeroesEvenVec = new DenseLocalOnHeapVector(nonZeroesEvenData),
- nonZeroesOddVec = new DenseLocalOnHeapVector(nonZeroesOddData);
-
- assertTrue("Vectors failed to initialize.",
- !isZero(nonZeroesEvenVec.getElement(0).get())
- && isZero(nonZeroesEvenVec.getElement(1).get())
- && isZero(nonZeroesOddVec.getElement(0).get())
- && !isZero(nonZeroesOddVec.getElement(1).get()));
-
- assertTrue("Iterator(s) failed to start.",
- nonZeroesEvenVec.nonZeroes().iterator().next() != null
- && nonZeroesOddVec.nonZeroes().iterator().next() != null);
-
- int nonZeroesActual = 0;
-
- for (Vector.Element e : nonZeroesEvenVec.nonZeroes()) {
- final int idx = e.index();
-
- final boolean odd = (idx & 1) == 1;
-
- final double val = e.get();
-
- assertTrue("Not an even index " + idx + ", for value " + val, !odd);
-
- assertTrue("Zero value " + val + " at even index " + idx, !isZero(val));
-
- nonZeroesActual++;
- }
-
- final int nonZeroesOddExp = (size + 1) / 2;
-
- assertEquals("Unexpected num of iterated odd non-zeroes.", nonZeroesOddExp, nonZeroesActual);
-
- assertEquals("Unexpected nonZeroElements of odd.", nonZeroesOddExp, nonZeroesEvenVec.nonZeroElements());
-
- nonZeroesActual = 0;
-
- for (Vector.Element e : nonZeroesOddVec.nonZeroes()) {
- final int idx = e.index();
-
- final boolean odd = (idx & 1) == 1;
-
- final double val = e.get();
-
- assertTrue("Not an odd index " + idx + ", for value " + val, odd);
-
- assertTrue("Zero value " + val + " at even index " + idx, !isZero(val));
-
- nonZeroesActual++;
- }
-
- final int nonZeroesEvenExp = size / 2;
-
- assertEquals("Unexpected num of iterated even non-zeroes", nonZeroesEvenExp, nonZeroesActual);
-
- assertEquals("Unexpected nonZeroElements of even", nonZeroesEvenExp, nonZeroesOddVec.nonZeroElements());
- }
-
- /** */
- @Test
- public void nonZeroesTest() {
- // todo make RandomVector constructor that accepts a function and use it here
- // in order to *reliably* test non-zeroes in there
- consumeSampleVectors(
- (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
- -> {
- int numZeroesActual = vec.size();
-
- for (Vector.Element e : vec.nonZeroes()) {
- numZeroesActual--;
-
- assertTrue("Unexpected zero at " + desc + ", index " + e.index(), !isZero(e.get()));
- }
-
- assertEquals("Unexpected num zeroes at " + desc, (int)numZeroes, numZeroesActual);
- }));
- }
-
- /** */
- @Test
- public void nonZeroesTestBound() {
- consumeSampleVectors(
- (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
- -> iteratorTestBound(vec.nonZeroes().iterator(), desc)));
- }
-
- /** */
- @Test
- public void nonZeroElementsTest() {
- consumeSampleVectors(
- (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
- -> assertEquals("Unexpected num zeroes at " + desc,
- (int)numZeroes, vec.size() - vec.nonZeroElements())));
- }
-
- /** */
- @Test
- public void allSpliteratorTest() {
- consumeSampleVectors(
- (v, desc) -> {
- final String desc1 = " " + desc;
-
- Spliterator<Double> spliterator = v.allSpliterator();
-
- assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
-
- assertNull(MathTestConstants.NOT_NULL_VAL + desc1, spliterator.trySplit());
-
- assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
-
- if (!readOnly(v))
- fillWithNonZeroes(v);
-
- spliterator = v.allSpliterator();
-
- assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.estimateSize(), v.size());
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.getExactSizeIfKnown(), v.size());
-
- assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
-
- Spliterator<Double> secondHalf = spliterator.trySplit();
-
- assertNull(MathTestConstants.NOT_NULL_VAL + desc1, secondHalf);
-
- spliterator.tryAdvance(x -> {
- });
- }
- );
- }
-
- /** */
- @Test
- public void nonZeroSpliteratorTest() {
- consumeSampleVectors(
- (v, desc) -> consumeSampleVectorsWithZeroes(v, (vec, numZeroes)
- -> {
- final String desc1 = " Num zeroes " + numZeroes + " " + desc;
-
- Spliterator<Double> spliterator = vec.nonZeroSpliterator();
-
- assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
-
- assertNull(MathTestConstants.NOT_NULL_VAL + desc1, spliterator.trySplit());
-
- assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
-
- spliterator = vec.nonZeroSpliterator();
-
- assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.estimateSize(), vec.size() - numZeroes);
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.getExactSizeIfKnown(), vec.size() - numZeroes);
-
- assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
-
- Spliterator<Double> secondHalf = spliterator.trySplit();
-
- assertNull(MathTestConstants.NOT_NULL_VAL + desc1, secondHalf);
-
- double[] data = new double[vec.size()];
-
- for (Vector.Element e : vec.all())
- data[e.index()] = e.get();
-
- spliterator = vec.nonZeroSpliterator();
-
- assertNotNull(MathTestConstants.NULL_VAL + desc1, spliterator);
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.estimateSize(),
- Arrays.stream(data).filter(x -> x != 0d).count());
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS + desc1, spliterator.getExactSizeIfKnown(),
- Arrays.stream(data).filter(x -> x != 0d).count());
-
- assertTrue(MathTestConstants.UNEXPECTED_VAL + desc1, spliterator.hasCharacteristics(ORDERED | SIZED));
-
- secondHalf = spliterator.trySplit();
-
- assertNull(MathTestConstants.NOT_NULL_VAL + desc1, secondHalf);
-
- if (!spliterator.tryAdvance(x -> {
- }))
- fail(MathTestConstants.NO_NEXT_ELEMENT + desc1);
- }));
- }
-
- /** */
- private void iteratorTestBound(Iterator<Vector.Element> it, String desc) {
- while (it.hasNext())
- assertNotNull(it.next());
-
- boolean expECaught = false;
-
- try {
- it.next();
- }
- catch (NoSuchElementException e) {
- expECaught = true;
- }
-
- assertTrue("Expected exception missed for " + desc,
- expECaught);
- }
-
- /** */
- private void consumeSampleVectorsWithZeroes(Vector sample,
- BiConsumer<Vector, Integer> consumer) {
- if (readOnly(sample)) {
- int numZeroes = 0;
-
- for (Vector.Element e : sample.all())
- if (isZero(e.get()))
- numZeroes++;
-
- consumer.accept(sample, numZeroes);
-
- return;
- }
-
- fillWithNonZeroes(sample);
-
- consumer.accept(sample, 0);
-
- final int sampleSize = sample.size();
-
- if (sampleSize == 0)
- return;
-
- for (Vector.Element e : sample.all())
- e.set(0);
-
- consumer.accept(sample, sampleSize);
-
- fillWithNonZeroes(sample);
-
- for (int testIdx : new int[] {0, sampleSize / 2, sampleSize - 1}) {
- final Vector.Element e = sample.getElement(testIdx);
-
- final double backup = e.get();
-
- e.set(0);
-
- consumer.accept(sample, 1);
-
- e.set(backup);
- }
-
- if (sampleSize < 3)
- return;
-
- sample.getElement(sampleSize / 3).set(0);
-
- sample.getElement((2 * sampleSize) / 3).set(0);
-
- consumer.accept(sample, 2);
- }
-
- /** */
- private void fillWithNonZeroes(Vector sample) {
- int idx = 0;
-
- for (Vector.Element e : sample.all())
- e.set(1 + idx++);
-
- assertEquals("Not all filled with non-zeroes", idx, sample.size());
- }
-
- /** */
- private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
- new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
- }
-
- /** */
- private boolean isZero(double val) {
- return val == 0.0;
- }
-
- /** */
- private boolean readOnly(Vector v) {
- return v instanceof RandomVector || v instanceof ConstantVector;
- }
-}
-
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java
deleted file mode 100644
index f1c2928..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorNormTest.java
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import org.apache.ignite.math.Vector;
-import org.junit.Test;
-
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class VectorNormTest {
- /** */
- @Test
- public void normalizeTest() {
- normalizeTest(2, (val, len) -> val / len, Vector::normalize);
- }
-
- /** */
- @Test
- public void normalizePowerTest() {
- for (double pow : new double[] {0, 0.5, 1, 2, 2.5, Double.POSITIVE_INFINITY})
- normalizeTest(pow, (val, norm) -> val / norm, (v) -> v.normalize(pow));
- }
-
- /** */
- @Test
- public void logNormalizeTest() {
- normalizeTest(2, (val, len) -> Math.log1p(val) / (len * Math.log(2)), Vector::logNormalize);
- }
-
- /** */
- @Test
- public void logNormalizePowerTest() {
- for (double pow : new double[] {1.1, 2, 2.5})
- normalizeTest(pow, (val, norm) -> Math.log1p(val) / (norm * Math.log(pow)), (v) -> v.logNormalize(pow));
- }
-
- /** */
- @Test
- public void kNormTest() {
- for (double pow : new double[] {0, 0.5, 1, 2, 2.5, Double.POSITIVE_INFINITY})
- toDoubleTest(pow, ref -> new Norm(ref, pow).calculate(), v -> v.kNorm(pow));
- }
-
- /** */
- @Test
- public void getLengthSquaredTest() {
- toDoubleTest(2.0, ref -> new Norm(ref, 2).sumPowers(), Vector::getLengthSquared);
- }
-
- /** */
- @Test
- public void getDistanceSquaredTest() {
- consumeSampleVectors((v, desc) -> {
- new VectorImplementationsTest.ElementsChecker(v, desc); // IMPL NOTE this initialises vector
-
- final int size = v.size();
- final Vector vOnHeap = new DenseLocalOnHeapVector(size);
- final Vector vOffHeap = new DenseLocalOffHeapVector(size);
-
- invertValues(v, vOnHeap);
- invertValues(v, vOffHeap);
-
- for (int idx = 0; idx < size; idx++) {
- final double exp = v.get(idx);
- final int idxMirror = size - 1 - idx;
-
- assertTrue("On heap vector difference at " + desc + ", idx " + idx,
- exp - vOnHeap.get(idxMirror) == 0);
- assertTrue("Off heap vector difference at " + desc + ", idx " + idx,
- exp - vOffHeap.get(idxMirror) == 0);
- }
-
- final double exp = vOnHeap.minus(v).getLengthSquared(); // IMPL NOTE this won't mutate vOnHeap
- final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(exp, v.getDistanceSquared(vOnHeap));
-
- assertTrue("On heap vector not close enough at " + desc + ", " + metric,
- metric.closeEnough());
-
- final VectorImplementationsTest.Metric metric1 = new VectorImplementationsTest.Metric(exp, v.getDistanceSquared(vOffHeap));
-
- assertTrue("Off heap vector not close enough at " + desc + ", " + metric1,
- metric1.closeEnough());
- });
- }
-
- /** */
- @Test
- public void dotTest() {
- consumeSampleVectors((v, desc) -> {
- new VectorImplementationsTest.ElementsChecker(v, desc); // IMPL NOTE this initialises vector
-
- final int size = v.size();
- final Vector v1 = new DenseLocalOnHeapVector(size);
-
- invertValues(v, v1);
-
- final double actual = v.dot(v1);
-
- double exp = 0;
-
- for (Vector.Element e : v.all())
- exp += e.get() * v1.get(e.index());
-
- final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(exp, actual);
-
- assertTrue("Dot product not close enough at " + desc + ", " + metric,
- metric.closeEnough());
- });
- }
-
- /** */
- private void invertValues(Vector src, Vector dst) {
- final int size = src.size();
-
- for (Vector.Element e : src.all()) {
- final int idx = size - 1 - e.index();
- final double val = e.get();
-
- dst.set(idx, val);
- }
- }
-
- /** */
- private void toDoubleTest(Double val, Function<double[], Double> calcRef, Function<Vector, Double> calcVec) {
- consumeSampleVectors((v, desc) -> {
- final int size = v.size();
- final double[] ref = new double[size];
-
- new VectorImplementationsTest.ElementsChecker(v, ref, desc); // IMPL NOTE this initialises vector and reference array
-
- final double exp = calcRef.apply(ref);
- final double obtained = calcVec.apply(v);
- final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(exp, obtained);
-
- assertTrue("Not close enough at " + desc
- + (val == null ? "" : ", value " + val) + ", " + metric, metric.closeEnough());
- });
- }
-
- /** */
- private void normalizeTest(double pow, BiFunction<Double, Double, Double> operation,
- Function<Vector, Vector> vecOperation) {
- consumeSampleVectors((v, desc) -> {
- final int size = v.size();
- final double[] ref = new double[size];
- final boolean nonNegative = pow != (int)pow;
-
- final VectorImplementationsTest.ElementsChecker checker = new VectorImplementationsTest.ElementsChecker(v, ref, desc + ", pow = " + pow, nonNegative);
- final double norm = new Norm(ref, pow).calculate();
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = operation.apply(ref[idx], norm);
-
- checker.assertCloseEnough(vecOperation.apply(v), ref);
- });
- }
-
- /** */
- private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
- new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
- }
-
- /** */
- private static class Norm {
- /** */
- private final double[] arr;
-
- /** */
- private final Double pow;
-
- /** */
- Norm(double[] arr, double pow) {
- this.arr = arr;
- this.pow = pow;
- }
-
- /** */
- double calculate() {
- if (pow.equals(0.0))
- return countNonZeroes(); // IMPL NOTE this is beautiful if you think of it
-
- if (pow.equals(Double.POSITIVE_INFINITY))
- return maxAbs();
-
- return Math.pow(sumPowers(), 1 / pow);
- }
-
- /** */
- double sumPowers() {
- if (pow.equals(0.0))
- return countNonZeroes();
-
- double norm = 0;
-
- for (double val : arr)
- norm += pow == 1 ? Math.abs(val) : Math.pow(val, pow);
-
- return norm;
- }
-
- /** */
- private int countNonZeroes() {
- int cnt = 0;
-
- final Double zero = 0.0;
-
- for (double val : arr)
- if (!zero.equals(val))
- cnt++;
-
- return cnt;
- }
-
- /** */
- private double maxAbs() {
- double res = 0;
-
- for (double val : arr) {
- final double abs = Math.abs(val);
-
- if (abs > res)
- res = abs;
- }
-
- return res;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java
deleted file mode 100644
index adcb2cc..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorToMatrixTest.java
+++ /dev/null
@@ -1,291 +0,0 @@
-package org.apache.ignite.math.impls.vector;
-
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.BiConsumer;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.matrix.RandomMatrix;
-import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrix;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-/** Tests for methods of Vector that involve Matrix. */
-public class VectorToMatrixTest {
- /** */
- private static final Map<Class<? extends Vector>, Class<? extends Matrix>> typesMap = typesMap();
-
- /** */
- private static final List<Class<? extends Vector>> likeMatrixUnsupported = Arrays.asList(FunctionVector.class,
- SingleElementVector.class, SingleElementVectorView.class, ConstantVector.class);
-
- /** */
- @Test
- public void testHaveLikeMatrix() throws InstantiationException, IllegalAccessException {
- for (Class<? extends Vector> key : typesMap.keySet()) {
- Class<? extends Matrix> val = typesMap.get(key);
-
- if (val == null && likeMatrixSupported(key))
- System.out.println("Missing test for implementation of likeMatrix for " + key.getSimpleName());
- }
- }
-
- /** */
- @Test
- public void testLikeMatrixUnsupported() throws Exception {
- consumeSampleVectors((v, desc) -> {
- if (likeMatrixSupported(v.getClass()))
- return;
-
- boolean expECaught = false;
-
- try {
- assertNull("Null view instead of exception in " + desc, v.likeMatrix(1, 1));
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expected exception was not caught in " + desc, expECaught);
- });
- }
-
- /** */
- @Test
- public void testLikeMatrix() {
- consumeSampleVectors((v, desc) -> {
- if (!availableForTesting(v))
- return;
-
- final Matrix matrix = v.likeMatrix(1, 1);
-
- Class<? extends Vector> key = v.getClass();
-
- Class<? extends Matrix> expMatrixType = typesMap.get(key);
-
- assertNotNull("Expect non-null matrix for " + key.getSimpleName() + " in " + desc, matrix);
-
- Class<? extends Matrix> actualMatrixType = matrix.getClass();
-
- assertTrue("Expected matrix type " + expMatrixType.getSimpleName()
- + " should be assignable from actual type " + actualMatrixType.getSimpleName() + " in " + desc,
- expMatrixType.isAssignableFrom(actualMatrixType));
-
- for (int rows : new int[] {1, 2})
- for (int cols : new int[] {1, 2}) {
- final Matrix actualMatrix = v.likeMatrix(rows, cols);
-
- String details = "rows " + rows + " cols " + cols;
-
- assertNotNull("Expect non-null matrix for " + details + " in " + desc,
- actualMatrix);
-
- assertEquals("Unexpected number of rows in " + desc, rows, actualMatrix.rowSize());
-
- assertEquals("Unexpected number of cols in " + desc, cols, actualMatrix.columnSize());
- }
- });
- }
-
- /** */
- @Test
- public void testToMatrix() {
- consumeSampleVectors((v, desc) -> {
- if (!availableForTesting(v))
- return;
-
- fillWithNonZeroes(v);
-
- final Matrix matrixRow = v.toMatrix(true);
-
- final Matrix matrixCol = v.toMatrix(false);
-
- for (Vector.Element e : v.all())
- assertToMatrixValue(desc, matrixRow, matrixCol, e.get(), e.index());
- });
- }
-
- /** */
- @Test
- public void testToMatrixPlusOne() {
- consumeSampleVectors((v, desc) -> {
- if (!availableForTesting(v))
- return;
-
- fillWithNonZeroes(v);
-
- for (double zeroVal : new double[] {-1, 0, 1, 2}) {
- final Matrix matrixRow = v.toMatrixPlusOne(true, zeroVal);
-
- final Matrix matrixCol = v.toMatrixPlusOne(false, zeroVal);
-
- final Metric metricRow0 = new Metric(zeroVal, matrixRow.get(0, 0));
-
- assertTrue("Not close enough row like " + metricRow0 + " at index 0 in " + desc,
- metricRow0.closeEnough());
-
- final Metric metricCol0 = new Metric(zeroVal, matrixCol.get(0, 0));
-
- assertTrue("Not close enough cols like " + metricCol0 + " at index 0 in " + desc,
- metricCol0.closeEnough());
-
- for (Vector.Element e : v.all())
- assertToMatrixValue(desc, matrixRow, matrixCol, e.get(), e.index() + 1);
- }
- });
- }
-
- /** */
- @Test
- public void testCross() {
- consumeSampleVectors((v, desc) -> {
- if (!availableForTesting(v))
- return;
-
- fillWithNonZeroes(v);
-
- for (int delta : new int[] {-1, 0, 1}) {
- final int size2 = v.size() + delta;
-
- if (size2 < 1)
- return;
-
- final Vector v2 = new DenseLocalOnHeapVector(size2);
-
- for (Vector.Element e : v2.all())
- e.set(size2 - e.index());
-
- assertCross(v, v2, desc);
- }
- });
- }
-
- /** */
- private void assertCross(Vector v1, Vector v2, String desc) {
- assertNotNull(v1);
- assertNotNull(v2);
-
- final Matrix res = v1.cross(v2);
-
- assertNotNull("Cross matrix is expected to be not null in " + desc, res);
-
- assertEquals("Unexpected number of rows in cross Matrix in " + desc, v1.size(), res.rowSize());
-
- assertEquals("Unexpected number of cols in cross Matrix in " + desc, v2.size(), res.columnSize());
-
- for (int row = 0; row < v1.size(); row++)
- for (int col = 0; col < v2.size(); col++) {
- final Metric metric = new Metric(v1.get(row) * v2.get(col), res.get(row, col));
-
- assertTrue("Not close enough cross " + metric + " at row " + row + " at col " + col
- + " in " + desc, metric.closeEnough());
- }
- }
-
- /** */
- private void assertToMatrixValue(String desc, Matrix matrixRow, Matrix matrixCol, double exp, int idx) {
- final Metric metricRow = new Metric(exp, matrixRow.get(0, idx));
-
- assertTrue("Not close enough row like " + metricRow + " at index " + idx + " in " + desc,
- metricRow.closeEnough());
-
- final Metric metricCol = new Metric(exp, matrixCol.get(idx, 0));
-
- assertTrue("Not close enough cols like " + matrixCol + " at index " + idx + " in " + desc,
- metricCol.closeEnough());
- }
-
- /** */
- private void fillWithNonZeroes(Vector sample) {
- if (sample instanceof RandomVector)
- return;
-
- for (Vector.Element e : sample.all())
- e.set(1 + e.index());
- }
-
- /** */
- private boolean availableForTesting(Vector v) {
- assertNotNull("Error in test: vector is null", v);
-
- if (!likeMatrixSupported(v.getClass()))
- return false;
-
- final boolean availableForTesting = typesMap.get(v.getClass()) != null;
-
- final Matrix actualLikeMatrix = v.likeMatrix(1, 1);
-
- assertTrue("Need to enable matrix testing for vector type " + v.getClass().getSimpleName(),
- availableForTesting || actualLikeMatrix == null);
-
- return availableForTesting;
- }
-
- /** Ignore test for given vector type. */
- private boolean likeMatrixSupported(Class<? extends Vector> clazz) {
- for (Class<? extends Vector> ignoredClass : likeMatrixUnsupported)
- if (ignoredClass.isAssignableFrom(clazz))
- return false;
-
- return true;
- }
-
- /** */
- private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
- new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
- }
-
- /** */
- private static Map<Class<? extends Vector>, Class<? extends Matrix>> typesMap() {
- return new LinkedHashMap<Class<? extends Vector>, Class<? extends Matrix>>() {{
- put(DenseLocalOnHeapVector.class, DenseLocalOnHeapMatrix.class);
- put(DenseLocalOffHeapVector.class, DenseLocalOffHeapMatrix.class);
- put(RandomVector.class, RandomMatrix.class);
- put(SparseLocalVector.class, SparseLocalOnHeapMatrix.class);
- put(SingleElementVector.class, null); // todo find out if we need SingleElementMatrix to match, or skip it
- put(ConstantVector.class, null);
- put(FunctionVector.class, null);
- put(PivotedVectorView.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
- put(SingleElementVectorView.class, null);
- put(MatrixVectorView.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
- put(DelegatingVector.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
- // IMPL NOTE check for presence of all implementations here will be done in testHaveLikeMatrix via Fixture
- }};
- }
-
- /** */
- private static class Metric { // todo consider if softer tolerance (like say 0.1 or 0.01) would make sense here
- /** */
- private final double exp;
-
- /** */
- private final double obtained;
-
- /** **/
- Metric(double exp, double obtained) {
- this.exp = exp;
- this.obtained = obtained;
- }
-
- /** */
- boolean closeEnough() {
- return new Double(exp).equals(obtained);
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- return "Metric{" + "expected=" + exp +
- ", obtained=" + obtained +
- '}';
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java
deleted file mode 100644
index 55893d0..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorViewTest.java
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.function.BiConsumer;
-import java.util.stream.IntStream;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/**
- * Unit tests for {@link VectorView}.
- */
-public class VectorViewTest {
- /** */
- private static final int OFFSET = 10;
-
- /** */
- private static final int VIEW_LENGTH = 80;
-
- /** */
- private static final String EXTERNALIZE_TEST_FILE_NAME = "externalizeTest";
-
- /** */
- private VectorView testVector;
-
- /** */
- private DenseLocalOnHeapVector parentVector;
-
- /** */
- private double[] parentData;
-
- /** */
- @Before
- public void setup() {
- parentVector = new DenseLocalOnHeapVector(MathTestConstants.STORAGE_SIZE);
-
- IntStream.range(0, MathTestConstants.STORAGE_SIZE).forEach(idx -> parentVector.set(idx, Math.random()));
-
- parentData = parentVector.getStorage().data().clone();
-
- testVector = new VectorView(parentVector, OFFSET, VIEW_LENGTH);
- }
-
- /** */
- @AfterClass
- public static void cleanup() throws IOException {
- Files.deleteIfExists(Paths.get(EXTERNALIZE_TEST_FILE_NAME));
- }
-
- /** */
- @Test
- public void testCopy() throws Exception {
- Vector cp = testVector.copy();
-
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, cp.equals(testVector));
- }
-
- /** */
- @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
- public void testLike() throws Exception {
- for (int card : new int[] {1, 2, 4, 8, 16, 32, 64, 128})
- consumeSampleVectors((v, desc) -> {
- Vector vLike = new VectorView(v, 0, 1).like(card);
-
- Class<? extends Vector> expType = v.getClass();
-
- assertNotNull("Expect non-null like vector for " + expType.getSimpleName() + " in " + desc, vLike);
-
- assertEquals("Expect size equal to cardinality at " + desc, card, vLike.size());
-
- Class<? extends Vector> actualType = vLike.getClass();
-
- assertTrue("Expected matrix type " + expType.getSimpleName()
- + " should be assignable from actual type " + actualType.getSimpleName() + " in " + desc,
- expType.isAssignableFrom(actualType));
-
- });
- }
-
- /** See also {@link VectorToMatrixTest#testLikeMatrix()}. */
- @Test
- public void testLikeMatrix() {
- consumeSampleVectors((v, desc) -> {
- boolean expECaught = false;
-
- try {
- assertNull("Null view instead of exception in " + desc, new VectorView(v, 0, 1).likeMatrix(1, 1));
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expected exception was not caught in " + desc, expECaught);
- });
- }
-
- /** */
- @Test
- public void testWriteReadExternal() throws Exception {
- assertNotNull("Unexpected null parent data", parentData);
-
- File f = new File(EXTERNALIZE_TEST_FILE_NAME);
-
- try {
- ObjectOutputStream objOutputStream = new ObjectOutputStream(new FileOutputStream(f));
-
- objOutputStream.writeObject(testVector);
-
- objOutputStream.close();
-
- ObjectInputStream objInputStream = new ObjectInputStream(new FileInputStream(f));
-
- VectorView readVector = (VectorView)objInputStream.readObject();
-
- objInputStream.close();
-
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, testVector.equals(readVector));
- }
- catch (ClassNotFoundException | IOException e) {
- fail(e.getMessage());
- }
- }
-
- /** */
- private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
- new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
- }
-
-}
[03/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java
new file mode 100644
index 0000000..8df19e4
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java
@@ -0,0 +1,89 @@
+/*
+ * 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.storage.matrix;
+
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Abstract class with base tests for each matrix storage.
+ */
+public abstract class MatrixBaseStorageTest<T extends MatrixStorage> extends ExternalizeTest<T> {
+ /** */
+ protected T storage;
+
+ /** */
+ @Before
+ public abstract void setUp();
+
+ /** */
+ @After
+ public void tearDown() throws Exception {
+ storage.destroy();
+ }
+
+ /** */
+ @Test
+ public void getSet() throws Exception {
+ int rows = MathTestConstants.STORAGE_SIZE;
+ int cols = MathTestConstants.STORAGE_SIZE;
+
+ for (int i = 0; i < rows; i++) {
+ for (int j = 0; j < cols; j++) {
+ double data = Math.random();
+
+ storage.set(i, j, data);
+
+ Assert.assertEquals(MathTestConstants.VAL_NOT_EQUALS, storage.get(i, j), data, MathTestConstants.NIL_DELTA);
+ }
+ }
+ }
+
+ /** */
+ @Test
+ public void columnSize() throws Exception {
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, storage.columnSize(), MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void rowSize() throws Exception {
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, storage.rowSize(), MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Override public void externalizeTest() {
+ fillMatrix();
+ super.externalizeTest(storage);
+ }
+
+ /** */
+ protected void fillMatrix() {
+ for (int i = 0; i < storage.rowSize(); i++) {
+ for (int j = 0; j < storage.columnSize(); j++)
+ storage.set(i, j, Math.random());
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java
new file mode 100644
index 0000000..a3b21bb
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java
@@ -0,0 +1,39 @@
+/*
+ * 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.storage.matrix;
+
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNull;
+
+/**
+ * Unit tests for {@link DenseOffHeapMatrixStorage}.
+ */
+public class MatrixOffHeapStorageTest extends MatrixBaseStorageTest<DenseOffHeapMatrixStorage> {
+ /** {@inheritDoc} */
+ @Override public void setUp() {
+ storage = new DenseOffHeapMatrixStorage(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void data() throws Exception {
+ assertNull(MathTestConstants.UNEXPECTED_VAL, storage.data());
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java
new file mode 100644
index 0000000..6353c38
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java
@@ -0,0 +1,141 @@
+/*
+ * 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.storage.matrix;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+import org.apache.ignite.math.MatrixStorage;
+import org.jetbrains.annotations.NotNull;
+
+import static org.apache.ignite.math.StorageConstants.COLUMN_STORAGE_MODE;
+import static org.apache.ignite.math.StorageConstants.RANDOM_ACCESS_MODE;
+import static org.apache.ignite.math.StorageConstants.ROW_STORAGE_MODE;
+import static org.apache.ignite.math.StorageConstants.SEQUENTIAL_ACCESS_MODE;
+
+/**
+ *
+ */
+class MatrixStorageFixtures {
+ /** */
+ private static final List<Supplier<Iterable<MatrixStorage>>> suppliers = Collections.singletonList(
+ (Supplier<Iterable<MatrixStorage>>) SparseLocalMatrixStorageFixture::new
+ );
+
+ /** */
+ void consumeSampleStorages(BiConsumer<Integer, Integer> paramsConsumer,
+ BiConsumer<MatrixStorage, String> consumer) {
+ for (Supplier<Iterable<MatrixStorage>> fixtureSupplier : suppliers) {
+ final Iterable<MatrixStorage> fixture = fixtureSupplier.get();
+
+ for (MatrixStorage matrixStorage : fixture) {
+ if (paramsConsumer != null)
+ paramsConsumer.accept(matrixStorage.rowSize(), matrixStorage.columnSize());
+
+ consumer.accept(matrixStorage, fixture.toString());
+ }
+ }
+ }
+
+ /** */
+ private static class SparseLocalMatrixStorageFixture implements Iterable<MatrixStorage> {
+ /** */
+ private final Integer[] rows = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 1024, null};
+ /** */
+ private final Integer[] cols = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 1024, 512, null};
+ /** */
+ private final Integer[] randomAccess = new Integer[] {SEQUENTIAL_ACCESS_MODE, RANDOM_ACCESS_MODE, null};
+ /** */
+ private final Integer[] rowStorage = new Integer[] {ROW_STORAGE_MODE, COLUMN_STORAGE_MODE, null};
+ /** */
+ private int sizeIdx = 0;
+ /** */
+ private int acsModeIdx = 0;
+ /** */
+ private int stoModeIdx = 0;
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<MatrixStorage> iterator() {
+ return new Iterator<MatrixStorage>() {
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return hasNextCol(sizeIdx) && hasNextRow(sizeIdx)
+ && hasNextAcsMode(acsModeIdx) && hasNextStoMode(stoModeIdx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public MatrixStorage next() {
+ if (!hasNext())
+ throw new NoSuchElementException(SparseLocalMatrixStorageFixture.this.toString());
+
+ MatrixStorage storage = new SparseLocalOnHeapMatrixStorage(
+ rows[sizeIdx], cols[sizeIdx], randomAccess[acsModeIdx], rowStorage[stoModeIdx]);
+
+ nextIdx();
+
+ return storage;
+ }
+
+ private void nextIdx() {
+ if (hasNextStoMode(stoModeIdx + 1)) {
+ stoModeIdx++;
+
+ return;
+ }
+
+ stoModeIdx = 0;
+
+ if (hasNextAcsMode(acsModeIdx + 1)) {
+ acsModeIdx++;
+
+ return;
+ }
+
+ acsModeIdx = 0;
+ sizeIdx++;
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ return "SparseLocalMatrixStorageFixture{ " + "rows=" + rows[sizeIdx] + ", cols=" + cols[sizeIdx] +
+ ", access mode=" + randomAccess[acsModeIdx] + ", storage mode=" + rowStorage[stoModeIdx] + "}";
+ }
+
+ /** */ private boolean hasNextRow(int idx) {
+ return rows[idx] != null;
+ }
+
+ /** */ private boolean hasNextCol(int idx) {
+ return cols[idx] != null;
+ }
+
+ /** */ private boolean hasNextAcsMode(int idx) {
+ return randomAccess[idx] != null;
+ }
+
+ /** */ private boolean hasNextStoMode(int idx) {
+ return rowStorage[idx] != null;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java
new file mode 100644
index 0000000..6ec09bd
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java
@@ -0,0 +1,73 @@
+/*
+ * 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.storage.matrix;
+
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.MatrixStorage;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests for {@link MatrixStorage} implementations.
+ *
+ * TODO: add attribute tests.
+ */
+public class MatrixStorageImplementationTest extends ExternalizeTest<MatrixStorage> {
+ /**
+ * The columnSize() and the rowSize() test.
+ */
+ @Test
+ public void sizeTest() {
+ final AtomicReference<Integer> expRowSize = new AtomicReference<>(0);
+ final AtomicReference<Integer> expColSize = new AtomicReference<>(0);
+
+ consumeSampleStorages((x, y) -> {
+ expRowSize.set(x);
+ expColSize.set(y);
+ },
+ (ms, desc) -> assertTrue("Expected size for " + desc, expColSize.get().equals(ms.columnSize()) && expRowSize.get().equals(ms.rowSize())));
+ }
+
+ /** */
+ @Test
+ public void getSetTest() {
+ consumeSampleStorages(null, (ms, desc) -> {
+ for (int i = 0; i < ms.rowSize(); i++) {
+ for (int j = 0; j < ms.columnSize(); j++) {
+ double random = Math.random();
+ ms.set(i, j, random);
+ assertTrue("Unexpected value for " + desc + " x:" + i + ", y:" + j, Double.compare(random, ms.get(i, j)) == 0);
+ }
+ }
+ });
+ }
+
+ /** */
+ @Override public void externalizeTest() {
+ consumeSampleStorages(null, (ms, desc) -> externalizeTest(ms));
+ }
+
+ /** */
+ private void consumeSampleStorages(BiConsumer<Integer, Integer> paramsConsumer,
+ BiConsumer<MatrixStorage, String> consumer) {
+ new MatrixStorageFixtures().consumeSampleStorages(paramsConsumer, consumer);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java
new file mode 100644
index 0000000..66fe9b4
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java
@@ -0,0 +1,126 @@
+/*
+ * 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.storage.matrix;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.internal.util.IgniteUtils;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.apache.ignite.testframework.junits.common.GridCommonTest;
+
+/**
+ * Tests for {@link SparseDistributedMatrixStorage}.
+ */
+@GridCommonTest(group = "Distributed Models")
+public class SparseDistributedMatrixStorageTest extends GridCommonAbstractTest {
+ /** Number of nodes in grid */
+ private static final int NODE_COUNT = 3;
+ /** Cache name. */
+ private static final String CACHE_NAME = "test-cache";
+ /** */
+ private static final String UNEXPECTED_ATTRIBUTE_VALUE = "Unexpected attribute value.";
+ /** Grid instance. */
+ private Ignite ignite;
+
+ /**
+ * Default constructor.
+ */
+ public SparseDistributedMatrixStorageTest() {
+ super(false);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void beforeTestsStarted() throws Exception {
+ for (int i = 1; i <= NODE_COUNT; i++)
+ startGrid(i);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTestsStopped() throws Exception {
+ stopAllGrids();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override protected void beforeTest() throws Exception {
+ ignite = grid(NODE_COUNT);
+
+ ignite.configuration().setPeerClassLoadingEnabled(true);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTest() throws Exception {
+ ignite.destroyCache(CACHE_NAME);
+ }
+
+ /** */
+ public void testCacheCreation() throws Exception {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ final int rows = MathTestConstants.STORAGE_SIZE;
+ final int cols = MathTestConstants.STORAGE_SIZE;
+
+ SparseDistributedMatrixStorage storage = new SparseDistributedMatrixStorage(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ assertNotNull("SparseDistributedMatrixStorage cache is null.", storage.cache());
+ }
+
+ /** */
+ public void testSetGet() throws Exception {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ final int rows = MathTestConstants.STORAGE_SIZE;
+ final int cols = MathTestConstants.STORAGE_SIZE;
+
+ SparseDistributedMatrixStorage storage = new SparseDistributedMatrixStorage(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ for (int i = 0; i < rows; i++) {
+ for (int j = 0; j < cols; j++) {
+ double v = Math.random();
+ storage.set(i, j, v);
+
+ assert Double.compare(v, storage.get(i, j)) == 0;
+ assert Double.compare(v, storage.get(i, j)) == 0;
+ }
+ }
+ }
+
+ /** */
+ public void testAttributes() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ final int rows = MathTestConstants.STORAGE_SIZE;
+ final int cols = MathTestConstants.STORAGE_SIZE;
+
+ SparseDistributedMatrixStorage storage = new SparseDistributedMatrixStorage(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ assertEquals(UNEXPECTED_ATTRIBUTE_VALUE, storage.rowSize(), rows);
+ assertEquals(UNEXPECTED_ATTRIBUTE_VALUE, storage.columnSize(), cols);
+
+ assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, storage.isArrayBased());
+ assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, storage.isDense());
+ assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, storage.isDistributed());
+
+ assertEquals(UNEXPECTED_ATTRIBUTE_VALUE, storage.isRandomAccess(), !storage.isSequentialAccess());
+ assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, storage.isRandomAccess());
+
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java
new file mode 100644
index 0000000..8a223fc
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java
@@ -0,0 +1,60 @@
+/*
+ * 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.storage.vector;
+
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+
+/**
+ * Unit tests for {@link SparseLocalOnHeapVectorStorage}.
+ */
+public class RandomAccessSparseVectorStorageTest extends VectorBaseStorageTest<SparseLocalOnHeapVectorStorage> {
+ /** */
+ @Override public void setUp() {
+ storage = new SparseLocalOnHeapVectorStorage(MathTestConstants.STORAGE_SIZE, StorageConstants.RANDOM_ACCESS_MODE);
+ }
+
+ /** */
+ @Test
+ public void data() throws Exception {
+ assertNull(MathTestConstants.NULL_VAL, storage.data());
+ }
+
+ /** */
+ @Test
+ public void isSequentialAccess() throws Exception {
+ assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isSequentialAccess());
+ }
+
+ /** */
+ @Test
+ public void isDense() throws Exception {
+ assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isDense());
+ }
+
+ /** */
+ @Test
+ public void isArrayBased() throws Exception {
+ assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isArrayBased());
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java
new file mode 100644
index 0000000..a7751d8
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java
@@ -0,0 +1,78 @@
+/*
+ * 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.storage.vector;
+
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.apache.ignite.math.impls.MathTestConstants.STORAGE_SIZE;
+import static org.apache.ignite.math.impls.MathTestConstants.UNEXPECTED_VAL;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests for {@link SparseLocalOffHeapVectorStorage}.
+ */
+public class SparseLocalOffHeapVectorStorageTest extends ExternalizeTest<SparseLocalOffHeapVectorStorage> {
+ /** */ private SparseLocalOffHeapVectorStorage testVectorStorage;
+
+ /** */
+ @Before
+ public void setup() {
+ testVectorStorage = new SparseLocalOffHeapVectorStorage(STORAGE_SIZE);
+ }
+
+ /** */
+ @After
+ public void teardown() {
+ testVectorStorage.destroy();
+ testVectorStorage = null;
+ }
+
+ /** */
+ @Test
+ public void testBasic() {
+ for (int i = 0; i < STORAGE_SIZE; i++) {
+ double testVal = Math.random();
+ testVectorStorage.set(i, testVal);
+ assertEquals(UNEXPECTED_VAL, testVal, testVectorStorage.get(i), 0d);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Test(expected = UnsupportedOperationException.class)
+ @Override public void externalizeTest() {
+ super.externalizeTest(new SparseLocalOffHeapVectorStorage(STORAGE_SIZE));
+ }
+
+ /** */
+ @Test
+ public void testAttributes() {
+ SparseLocalOffHeapVectorStorage testVectorStorage = new SparseLocalOffHeapVectorStorage(STORAGE_SIZE);
+
+ assertTrue(UNEXPECTED_VAL, testVectorStorage.isRandomAccess());
+ assertFalse(UNEXPECTED_VAL, testVectorStorage.isSequentialAccess());
+ assertFalse(UNEXPECTED_VAL, testVectorStorage.isDense());
+ assertFalse(UNEXPECTED_VAL, testVectorStorage.isArrayBased());
+ assertFalse(UNEXPECTED_VAL, testVectorStorage.isDistributed());
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java
new file mode 100644
index 0000000..2afc97b
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java
@@ -0,0 +1,58 @@
+/*
+ * 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.storage.vector;
+
+import java.util.Arrays;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit test for {@link ArrayVectorStorage}.
+ */
+public class VectorArrayStorageTest extends VectorBaseStorageTest<ArrayVectorStorage> {
+ /** */
+ @Override public void setUp() {
+ storage = new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void isArrayBased() throws Exception {
+ assertTrue(MathTestConstants.WRONG_ATTRIBUTE_VAL, storage.isArrayBased());
+
+ assertTrue(MathTestConstants.WRONG_ATTRIBUTE_VAL, new ArrayVectorStorage().isArrayBased());
+ }
+
+ /** */
+ @Test
+ public void data() throws Exception {
+ assertNotNull(MathTestConstants.NULL_DATA_STORAGE, storage.data());
+
+ assertEquals(MathTestConstants.WRONG_DATA_SIZE, storage.data().length, MathTestConstants.STORAGE_SIZE);
+
+ assertTrue(MathTestConstants.UNEXPECTED_DATA_VAL, Arrays.equals(storage.data(), new double[MathTestConstants.STORAGE_SIZE]));
+
+ assertNull(MathTestConstants.UNEXPECTED_DATA_VAL, new ArrayVectorStorage().data());
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java
new file mode 100644
index 0000000..988f8c3
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java
@@ -0,0 +1,69 @@
+/*
+ * 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.storage.vector;
+
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Abstract class with base tests for each vector storage.
+ */
+public abstract class VectorBaseStorageTest<T extends VectorStorage> extends ExternalizeTest<T> {
+ /** */
+ protected T storage;
+
+ /** */
+ @Before
+ public abstract void setUp();
+
+ /** */
+ @After
+ public void tearDown() throws Exception {
+ storage.destroy();
+ }
+
+ /** */
+ @Test
+ public void getSet() throws Exception {
+ for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++) {
+ double random = Math.random();
+
+ storage.set(i, random);
+
+ assertEquals(MathTestConstants.WRONG_DATA_ELEMENT, storage.get(i), random, MathTestConstants.NIL_DELTA);
+ }
+ }
+
+ /** */
+ @Test
+ public void size() {
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.size() == MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Override public void externalizeTest() {
+ super.externalizeTest(storage);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java
new file mode 100644
index 0000000..2645926
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java
@@ -0,0 +1,73 @@
+/*
+ * 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.storage.vector;
+
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests for {@link DenseLocalOffHeapVectorStorage}.
+ */
+public class VectorOffheapStorageTest extends VectorBaseStorageTest<DenseLocalOffHeapVectorStorage> {
+ /** */
+ @Before
+ public void setUp() {
+ storage = new DenseLocalOffHeapVectorStorage(MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void isArrayBased() throws Exception {
+ assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isArrayBased());
+ }
+
+ /** */
+ @Test
+ public void data() throws Exception {
+ assertNull(MathTestConstants.NULL_VAL, storage.data());
+ }
+
+ /** */
+ @Test
+ public void isSequentialAccess() throws Exception {
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isSequentialAccess());
+ }
+
+ /** */
+ @Test
+ public void isDense() throws Exception {
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isDense());
+ }
+
+ /** */
+ @Test
+ public void equalsTest() {
+ //noinspection EqualsWithItself
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, storage.equals(storage));
+
+ //noinspection EqualsBetweenInconvertibleTypes
+ assertFalse(MathTestConstants.VALUES_SHOULD_BE_NOT_EQUALS,
+ storage.equals(new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE)));
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java
new file mode 100644
index 0000000..c7927a5
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java
@@ -0,0 +1,543 @@
+/*
+ * 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.vector;
+
+import java.util.Arrays;
+import java.util.stream.StreamSupport;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.math.impls.storage.vector.ArrayVectorStorage;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit test for {@link AbstractVector}.
+ */
+public class AbstractVectorTest {
+ /** */
+ private AbstractVector testVector;
+
+ /** */
+ @Before
+ public void setUp() {
+ testVector = getAbstractVector();
+ }
+
+ /** */
+ @Test
+ public void setStorage() {
+ testVector.setStorage(createStorage());
+
+ assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void size() {
+ testVector.setStorage(createStorage());
+ assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE);
+
+ testVector.setStorage(new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE + MathTestConstants.STORAGE_SIZE));
+ assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE + MathTestConstants.STORAGE_SIZE);
+
+ testVector = getAbstractVector(createStorage());
+ assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE);
+ }
+
+ /** */
+ @Test
+ public void getPositive() {
+ testVector = getAbstractVector(createStorage());
+
+ for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
+ assertNotNull(MathTestConstants.NULL_VALUES, testVector.get(i));
+
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void getNegative0() {
+ testVector.get(0);
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void getNegative1() {
+ testVector.setStorage(createStorage());
+
+ testVector.get(-1);
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void getNegative2() {
+ testVector.setStorage(createStorage());
+
+ testVector.get(testVector.size() + 1);
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void getXNegative0() {
+ testVector.getX(0);
+ }
+
+ /** */
+ @Test(expected = ArrayIndexOutOfBoundsException.class)
+ public void getXNegative1() {
+ testVector.setStorage(createStorage());
+
+ testVector.getX(-1);
+ }
+
+ /** */
+ @Test(expected = ArrayIndexOutOfBoundsException.class)
+ public void getXNegative2() {
+ testVector.setStorage(createStorage());
+
+ testVector.getX(MathTestConstants.STORAGE_SIZE + 1);
+ }
+
+ /** */
+ @Test
+ public void set() {
+ double[] data = initVector();
+
+ for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
+ testVector.set(i, Math.exp(data[i]));
+
+ for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.get(i), Math.exp(data[i]), MathTestConstants.NIL_DELTA);
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void setNegative0() {
+ testVector.set(-1, -1);
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void setNegative1() {
+ initVector();
+
+ testVector.set(-1, -1);
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void setNegative2() {
+ initVector();
+
+ testVector.set(MathTestConstants.STORAGE_SIZE + 1, -1);
+ }
+
+ /** */
+ @Test(expected = IndexOutOfBoundsException.class)
+ public void setXNegative0() {
+ initVector();
+
+ testVector.setX(-1, -1);
+ }
+
+ /** */
+ @Test(expected = IndexOutOfBoundsException.class)
+ public void setXNegative1() {
+ initVector();
+
+ testVector.setX(MathTestConstants.STORAGE_SIZE + 1, -1);
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void setXNegative2() {
+ testVector.setX(-1, -1);
+ }
+
+ /** */
+ @Test
+ public void isZero() {
+ assertTrue(MathTestConstants.UNEXPECTED_VAL, testVector.isZero(0d));
+
+ assertFalse(MathTestConstants.UNEXPECTED_VAL, testVector.isZero(1d));
+ }
+
+ /** */
+ @Test
+ public void guid() {
+ assertNotNull(MathTestConstants.NULL_GUID, testVector.guid());
+
+ assertEquals(MathTestConstants.UNEXPECTED_GUID_VAL, testVector.guid(), testVector.guid());
+
+ assertFalse(MathTestConstants.EMPTY_GUID, testVector.guid().toString().isEmpty());
+
+ testVector = getAbstractVector(createStorage());
+
+ assertNotNull(MathTestConstants.NULL_GUID, testVector.guid());
+
+ assertEquals(MathTestConstants.UNEXPECTED_GUID_VAL, testVector.guid(), testVector.guid());
+
+ assertFalse(MathTestConstants.EMPTY_GUID, testVector.guid().toString().isEmpty());
+ }
+
+ /** */
+ @Test
+ public void equalsTest() {
+ VectorStorage storage = createStorage();
+
+ AbstractVector testVector1 = getAbstractVector();
+
+ testVector1.setStorage(storage);
+
+ AbstractVector testVector2 = getAbstractVector();
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector, testVector);
+
+ testVector2.setStorage(storage);
+
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, testVector1.equals(testVector2));
+
+ assertFalse(MathTestConstants.VALUES_SHOULD_BE_NOT_EQUALS, testVector1.equals(testVector));
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void all() {
+ assertNotNull(MathTestConstants.NULL_VAL, testVector.all());
+
+ assertNotNull(MathTestConstants.NULL_VAL, getAbstractVector(createStorage()).all());
+
+ getAbstractVector().all().iterator().next();
+ }
+
+ /** */
+ @Test
+ public void nonZeroElements() {
+ VectorStorage storage = createStorage();
+
+ double[] data = storage.data();
+
+ testVector = getAbstractVector(storage);
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.nonZeroElements(), Arrays.stream(data).filter(x -> x != 0d).count());
+
+ addNilValues(data);
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.nonZeroElements(), Arrays.stream(data).filter(x -> x != 0d).count());
+ }
+
+ /** */
+ @Test
+ public void foldMapWithSecondVector() {
+ double[] data0 = initVector();
+
+ VectorStorage storage1 = createStorage();
+
+ double[] data1 = storage1.data().clone();
+
+ AbstractVector testVector1 = getAbstractVector(storage1);
+
+ String testVal = "";
+
+ for (int i = 0; i < data0.length; i++)
+ testVal += data0[i] + data1[i];
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.foldMap(testVector1, (string, xi) -> string.concat(xi.toString()), Functions.PLUS, ""), testVal);
+ }
+
+ /** */
+ @Test
+ public void nonZeroes() {
+ assertNotNull(MathTestConstants.NULL_VAL, testVector.nonZeroes());
+
+ double[] data = initVector();
+
+ assertNotNull(MathTestConstants.NULL_VAL, testVector.nonZeroes());
+
+ Assert.assertEquals(MathTestConstants.VAL_NOT_EQUALS, StreamSupport.stream(testVector.nonZeroes().spliterator(), false).count(), Arrays.stream(data).filter(x -> x != 0d).count());
+
+ addNilValues(data);
+
+ Assert.assertEquals(MathTestConstants.VAL_NOT_EQUALS, StreamSupport.stream(testVector.nonZeroes().spliterator(), false).count(), Arrays.stream(data).filter(x -> x != 0d).count());
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void nonZeroesEmpty() {
+ testVector.nonZeroes().iterator().next();
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void assign() {
+ testVector.assign(MathTestConstants.TEST_VAL);
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void assignArr() {
+ testVector.assign(new double[1]);
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void assignArrEmpty() {
+ testVector.assign(new double[0]);
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void dotNegative() {
+ testVector.dot(getAbstractVector(createEmptyStorage()));
+ }
+
+ /** */
+ @Test
+ public void dotSelf() {
+ double[] data = initVector();
+
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.dotSelf(), Arrays.stream(data).reduce(0, (x, y) -> x + y * y), MathTestConstants.NIL_DELTA);
+ }
+
+ /** */
+ @Test
+ public void getStorage() {
+ assertNotNull(MathTestConstants.NULL_VAL, getAbstractVector(createEmptyStorage()));
+ assertNotNull(MathTestConstants.NULL_VAL, getAbstractVector(createStorage()));
+ testVector.setStorage(createStorage());
+ assertNotNull(MathTestConstants.NULL_VAL, testVector.getStorage());
+ }
+
+ /** */
+ @Test
+ public void getElement() {
+ double[] data = initVector();
+
+ for (int i = 0; i < data.length; i++) {
+ assertNotNull(MathTestConstants.NULL_VAL, testVector.getElement(i));
+
+ assertEquals(MathTestConstants.UNEXPECTED_VAL, testVector.getElement(i).get(), data[i], MathTestConstants.NIL_DELTA);
+
+ testVector.getElement(i).set(++data[i]);
+
+ assertEquals(MathTestConstants.UNEXPECTED_VAL, testVector.getElement(i).get(), data[i], MathTestConstants.NIL_DELTA);
+ }
+ }
+
+ /**
+ * Create {@link AbstractVector} with storage for tests.
+ *
+ * @param storage {@link VectorStorage}
+ * @return AbstractVector.
+ */
+ private AbstractVector getAbstractVector(VectorStorage storage) {
+ return new AbstractVector(storage) { // TODO: find out how to fix warning about missing constructor
+ /** */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector copy() {
+ return getAbstractVector(this.getStorage());
+ }
+
+ /** */
+ @Override public Vector like(int crd) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector normalize() {
+ return null;
+ }
+
+ /** */
+ @Override public Vector normalize(double power) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector logNormalize() {
+ return null;
+ }
+
+ /** */
+ @Override public Vector logNormalize(double power) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector viewPart(int off, int len) {
+ return null;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+ };
+ }
+
+ /**
+ * Create empty {@link AbstractVector} for tests.
+ *
+ * @return AbstractVector.
+ */
+ private AbstractVector getAbstractVector() {
+ return new AbstractVector() { // TODO: find out how to fix warning about missing constructor
+ /** */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return null;
+ }
+
+ /** */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** */
+ @Override public Vector copy() {
+ return getAbstractVector(this.getStorage());
+ }
+
+ /** */
+ @Override public Vector like(int crd) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector normalize() {
+ return null;
+ }
+
+ /** */
+ @Override public Vector normalize(double power) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector logNormalize() {
+ return null;
+ }
+
+ /** */
+ @Override public Vector logNormalize(double power) {
+ return null;
+ }
+
+ /** */
+ @Override public Vector viewPart(int off, int len) {
+ return null;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+ };
+ }
+
+ /**
+ * Create {@link VectorStorage} for tests.
+ *
+ * @return VectorStorage
+ */
+ private VectorStorage createEmptyStorage() {
+ return new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE);
+ }
+
+ /**
+ * Create filled {@link VectorStorage} for tests.
+ *
+ * @return VectorStorage.
+ */
+ private VectorStorage createStorage() {
+ ArrayVectorStorage storage = new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE);
+
+ for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
+ storage.set(i, Math.random());
+
+ return storage;
+ }
+
+ /**
+ * Init vector and return initialized values.
+ *
+ * @return Initial values.
+ */
+ private double[] initVector() {
+ VectorStorage storage = createStorage();
+ double[] data = storage.data().clone();
+
+ testVector = getAbstractVector(storage);
+ return data;
+ }
+
+ /**
+ * Add some zeroes to vector elements.
+ */
+ private void addNilValues() {
+ testVector.set(10, 0);
+ testVector.set(50, 0);
+ }
+
+ /**
+ * Add some zeroes to vector elements. Also set zeroes to the same elements in reference array data
+ */
+ private void addNilValues(double[] testRef) {
+ addNilValues();
+ testRef[10] = 0;
+ testRef[50] = 0;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java
new file mode 100644
index 0000000..f276820
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java
@@ -0,0 +1,417 @@
+package org.apache.ignite.math.impls.vector;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.stream.IntStream;
+import junit.framework.TestCase;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.internal.util.IgniteUtils;
+import org.apache.ignite.math.IdentityValueMapper;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorKeyMapper;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.apache.ignite.testframework.junits.common.GridCommonTest;
+
+/**
+ * Tests for {@link CacheVector}.
+ */
+@GridCommonTest(group = "Distributed Models")
+public class CacheVectorTest extends GridCommonAbstractTest {
+ /** Number of nodes in grid */
+ private static final int NODE_COUNT = 3;
+ /** Cache name. */
+ private static final String CACHE_NAME = "test-cache";
+ /** Cache size. */
+ private static final int size = MathTestConstants.STORAGE_SIZE;
+ /** Grid instance. */
+ private Ignite ignite;
+ /** Default key mapper. */
+ private VectorKeyMapper<Integer> keyMapper = new TestKeyMapper();
+
+ /**
+ * Default constructor.
+ */
+ public CacheVectorTest() {
+ super(false);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void beforeTestsStarted() throws Exception {
+ for (int i = 1; i <= NODE_COUNT; i++)
+ startGrid(i);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTestsStopped() throws Exception {
+ stopAllGrids();
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void beforeTest() throws Exception {
+ ignite = grid(NODE_COUNT);
+
+ ignite.configuration().setPeerClassLoadingEnabled(true);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTest() throws Exception {
+ ignite.destroyCache(CACHE_NAME);
+ }
+
+ /** */
+ public void testGetSet() throws Exception {
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ for (int i = 0; i < size; i++) {
+ double random = Math.random();
+ cacheVector.set(i, random);
+ assertEquals("Unexpected value.", random, cacheVector.get(i), 0d);
+ }
+ }
+
+ /** */
+ public void testMap() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+
+ cacheVector.map(value -> 110d);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), 110d, 0d);
+ }
+
+ /** */
+ public void testMapBiFunc() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+
+ cacheVector.map(Functions.PLUS, 1d);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), 1d, 0d);
+ }
+
+ /** */
+ public void testSum() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+
+ assertEquals("Unexpected value.", cacheVector.sum(), 0d, 0d);
+
+ cacheVector.assign(1d);
+
+ assertEquals("Unexpected value.", cacheVector.sum(), size, 0d);
+ }
+
+ /** */
+ public void testSumNegative() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ try {
+ double d = cacheVector.sum();
+ fail();
+ }
+ catch (NullPointerException e) {
+ // No-op.
+ }
+ }
+
+ /** */
+ public void testAssign() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+
+ cacheVector.assign(1d);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), 1d, 0d);
+ }
+
+ /** */
+ public void testAssignRange() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ cacheVector.assign(IntStream.range(0, size).asDoubleStream().toArray());
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), i, 0d);
+ }
+
+ /** */
+ public void testAssignVector() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
+
+ cacheVector.assign(testVec);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), testVec.get(i), 0d);
+ }
+
+ /** */
+ public void testAssignFunc() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ cacheVector.assign(idx -> idx);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), i, 0d);
+ }
+
+ /** */
+ public void testPlus() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+
+ cacheVector.plus(1d);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), 1d, 0d);
+ }
+
+ /** */
+ public void testPlusVec() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
+
+ try {
+ cacheVector.plus(testVec);
+ TestCase.fail();
+ }
+ catch (UnsupportedOperationException ignored) {
+
+ }
+ }
+
+ /** */
+ public void testDivide() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ final int size = MathTestConstants.STORAGE_SIZE;
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+ cacheVector.assign(1d);
+
+ cacheVector.divide(2d);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), 1d / 2d, 0d);
+ }
+
+ /** */
+ public void testTimes() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ final int size = MathTestConstants.STORAGE_SIZE;
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ initVector(cacheVector);
+ cacheVector.assign(1d);
+
+ cacheVector.times(2d);
+
+ for (int i = 0; i < size; i++)
+ assertEquals("Unexpected value.", cacheVector.get(i), 2d, 0d);
+ }
+
+ /** */
+ public void testTimesVector() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ cacheVector.assign(1d);
+ Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
+
+ try {
+ cacheVector.times(testVec);
+ TestCase.fail();
+ }
+ catch (UnsupportedOperationException ignored) {
+
+ }
+
+ }
+
+ /** */
+ public void testMin() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
+
+ cacheVector.assign(testVec);
+
+ assertEquals("Unexpected value.", cacheVector.minValue(), 0d, 0d);
+ }
+
+ /** */
+ public void testMax() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
+
+ cacheVector.assign(testVec);
+
+ assertEquals("Unexpected value.", cacheVector.maxValue(), testVec.get(size - 1), 0d);
+ }
+
+ /** */
+ public void testLike() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ try {
+ cacheVector.like(size);
+ TestCase.fail("Unsupported case");
+ }
+ catch (UnsupportedOperationException ignored) {
+
+ }
+ }
+
+ /** */
+ public void testLikeMatrix() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ try {
+ cacheVector.likeMatrix(size, size);
+ TestCase.fail("Unsupported case");
+ }
+ catch (UnsupportedOperationException ignored) {
+
+ }
+ }
+
+ /** */
+ public void testCopy() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ try {
+ cacheVector.copy();
+ TestCase.fail("Unsupported case");
+ }
+ catch (UnsupportedOperationException ignored) {
+
+ }
+ }
+
+ /** */
+ public void testExternalize() throws IOException, ClassNotFoundException {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ IdentityValueMapper valMapper = new IdentityValueMapper();
+ CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
+
+ cacheVector.set(1, 1.0);
+
+ ByteArrayOutputStream byteArrOutputStream = new ByteArrayOutputStream();
+ ObjectOutputStream objOutputStream = new ObjectOutputStream(byteArrOutputStream);
+
+ objOutputStream.writeObject(cacheVector);
+
+ ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(byteArrOutputStream.toByteArray());
+ ObjectInputStream objInputStream = new ObjectInputStream(byteArrInputStream);
+
+ CacheVector objRestored = (CacheVector)objInputStream.readObject();
+
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, cacheVector.equals(objRestored));
+ assertEquals(MathTestConstants.VAL_NOT_EQUALS, objRestored.get(1), 1.0, 0.0);
+ }
+
+ /** */
+ private void initVector(CacheVector cacheVector) {
+ for (int i = 0; i < cacheVector.size(); i++)
+ cacheVector.set(i, 0d);
+ }
+
+ /** */
+ private IgniteCache<Integer, Double> getCache() {
+ assert ignite != null;
+
+ CacheConfiguration cfg = new CacheConfiguration();
+ cfg.setName(CACHE_NAME);
+
+ IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(CACHE_NAME);
+
+ assert cache != null;
+ return cache;
+ }
+
+ /** */ private static class TestKeyMapper implements VectorKeyMapper<Integer> {
+ /** {@inheritDoc} */
+ @Override public Integer apply(int i) {
+ return i;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isValid(Integer i) {
+ return i < size;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java
new file mode 100644
index 0000000..2ed42bc
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java
@@ -0,0 +1,52 @@
+/*
+ * 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.vector;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class ConstantVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new ConstantVector(-1, 1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void zeroSizeTest() {
+ assertEquals("Zero size.", IMPOSSIBLE_SIZE,
+ new ConstantVector(0, 1).size());
+ }
+
+ /** */
+ @Test
+ public void primitiveTest() {
+ assertEquals("1 size.", 1,
+ new ConstantVector(1, 1).size());
+
+ assertEquals("2 size.", 2,
+ new ConstantVector(2, 1).size());
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java
new file mode 100644
index 0000000..82e4e0b
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java
@@ -0,0 +1,62 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Vector;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class DelegatingVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test
+ public void basicTest() {
+ final Vector parent = new DenseLocalOnHeapVector(new double[] {0, 1});
+
+ final Vector delegate = new DelegatingVector(parent);
+
+ final int size = parent.size();
+
+ assertEquals("Delegate size differs from expected.", size, delegate.size());
+
+ for (int idx = 0; idx < size; idx++)
+ assertDelegate(parent, delegate, idx);
+ }
+
+ /** */
+ private void assertDelegate(Vector parent, Vector delegate, int idx) {
+ assertValue(parent, delegate, idx);
+
+ parent.set(idx, parent.get(idx) + 1);
+
+ assertValue(parent, delegate, idx);
+
+ delegate.set(idx, delegate.get(idx) + 2);
+
+ assertValue(parent, delegate, idx);
+ }
+
+ /** */
+ private void assertValue(Vector parent, Vector delegate, int idx) {
+ assertEquals("Unexpected value at index " + idx, parent.get(idx), delegate.get(idx), 0d);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java
new file mode 100644
index 0000000..d62f35f
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java
@@ -0,0 +1,59 @@
+/*
+ * 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.vector;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class DenseLocalOffHeapVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new DenseLocalOffHeapVector(-1).size());
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void nullArrayTest() {
+ assertEquals("Null array.", IMPOSSIBLE_SIZE,
+ new DenseLocalOffHeapVector(null).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void zeroSizeTest() {
+ assertEquals("0 size.", IMPOSSIBLE_SIZE,
+ new DenseLocalOffHeapVector(new double[0]).size());
+ }
+
+ /** */
+ @Test
+ public void primitiveTest() {
+ assertEquals("1 size.", 1,
+ new DenseLocalOffHeapVector(new double[1]).size());
+
+ assertEquals("2 size.", 2,
+ new DenseLocalOffHeapVector(new double[2]).size());
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java
new file mode 100644
index 0000000..c10778e
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java
@@ -0,0 +1,163 @@
+/*
+ * 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.vector;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class DenseLocalOnHeapVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
+ public void mapInvalidArgsTest() {
+ assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
+ put("invalid", 99);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void mapMissingArgsTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("arr", new double[0]);
+ put("shallowCopyMissing", "whatever");
+ }};
+
+ assertEquals("Expect exception due to missing args.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(test).size());
+ }
+
+ /** */
+ @Test(expected = ClassCastException.class)
+ public void mapInvalidArrTypeTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("size", "whatever");
+ }};
+
+ assertEquals("Expect exception due to invalid arr type.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(test).size());
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void mapInvalidCopyTypeTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("arr", new double[0]);
+ put("shallowCopy", 0);
+ }};
+
+ assertEquals("Expect exception due to invalid copy type.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(test).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void mapNullTest() {
+ //noinspection ConstantConditions
+ assertEquals("Null map args.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector((Map<String, Object>)null).size());
+ }
+
+ /** */
+ @Test
+ public void mapTest() {
+ assertEquals("Size from args.", 99,
+ new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
+ put("size", 99);
+ }}).size());
+
+ final double[] test = new double[99];
+
+ assertEquals("Size from array in args.", test.length,
+ new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
+ put("arr", test);
+ put("copy", false);
+ }}).size());
+
+ assertEquals("Size from array in args, shallow copy.", test.length,
+ new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
+ put("arr", test);
+ put("copy", true);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(-1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullCopyTest() {
+ assertEquals("Null array to non-shallow copy.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(null, false).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullDefaultCopyTest() {
+ assertEquals("Null array default copy.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector((double[])null).size());
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void defaultConstructorTest() {
+ assertEquals("Default constructor.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector().size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullArrShallowCopyTest() {
+ assertEquals("Null array shallow copy.", IMPOSSIBLE_SIZE,
+ new DenseLocalOnHeapVector(null, true).size());
+ }
+
+ /** */
+ @Test
+ public void primitiveTest() {
+ assertEquals("0 size shallow copy.", 0,
+ new DenseLocalOnHeapVector(new double[0], true).size());
+
+ assertEquals("0 size.", 0,
+ new DenseLocalOnHeapVector(new double[0], false).size());
+
+ assertEquals("1 size shallow copy.", 1,
+ new DenseLocalOnHeapVector(new double[1], true).size());
+
+ assertEquals("1 size.", 1,
+ new DenseLocalOnHeapVector(new double[1], false).size());
+
+ assertEquals("0 size default copy.", 0,
+ new DenseLocalOnHeapVector(new double[0]).size());
+
+ assertEquals("1 size default copy.", 1,
+ new DenseLocalOnHeapVector(new double[1]).size());
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java
new file mode 100644
index 0000000..57c96d1
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java
@@ -0,0 +1,121 @@
+/*
+ * 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.vector;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.IntToDoubleFunction;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.functions.IntDoubleToVoidFunction;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class FunctionVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
+ public void mapInvalidArgsTest() {
+ assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
+ new FunctionVector(new HashMap<String, Object>() {{
+ put("invalid", 99);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void mapMissingArgsTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("size", 1);
+ put("paramMissing", "whatever");
+ }};
+
+ assertEquals("Expect exception due to missing args.",
+ -1, new FunctionVector(test).size());
+ }
+
+ /** */
+ @Test(expected = ClassCastException.class)
+ public void mapInvalidParamTypeTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("size", "whatever");
+
+ put("getFunc", (IntToDoubleFunction)i -> i);
+ }};
+
+ assertEquals("Expect exception due to invalid param type.", IMPOSSIBLE_SIZE,
+ new FunctionVector(test).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void mapNullTest() {
+ //noinspection ConstantConditions
+ assertEquals("Null map args.", IMPOSSIBLE_SIZE,
+ new FunctionVector(null).size());
+ }
+
+ /** */
+ @Test
+ public void mapTest() {
+ assertEquals("Size from args.", 99,
+ new FunctionVector(new HashMap<String, Object>() {{
+ put("size", 99);
+
+ put("getFunc", (IgniteFunction<Integer, Double>)i -> (double)i);
+ }}).size());
+
+ assertEquals("Size from args with setFunc.", 99,
+ new FunctionVector(new HashMap<String, Object>() {{
+ put("size", 99);
+
+ put("getFunc", (IgniteFunction<Integer, Double>)i -> (double)i);
+
+ put("setFunc", (IntDoubleToVoidFunction)(integer, aDouble) -> {
+ });
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new FunctionVector(-1, (i) -> (double)i).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void zeroSizeTest() {
+ assertEquals("0 size.", IMPOSSIBLE_SIZE,
+ new FunctionVector(0, (i) -> (double)i).size());
+ }
+
+ /** */
+ @Test
+ public void primitiveTest() {
+ assertEquals("1 size.", 1,
+ new FunctionVector(1, (i) -> (double)i).size());
+
+ assertEquals("2 size.", 2,
+ new FunctionVector(2, (i) -> (double)i).size());
+ }
+}
[10/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
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 < b ? -1 : a > 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);
+ }
+}
[05/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java
new file mode 100644
index 0000000..fa311e0
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java
@@ -0,0 +1,158 @@
+/*
+ * 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.NonPositiveDefiniteMatrixException;
+import org.apache.ignite.math.exceptions.NonSymmetricMatrixException;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/** */
+public class CholeskyDecompositionTest {
+ /** */
+ @Test
+ public void basicTest() {
+ basicTest(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ }));
+ }
+
+ /**
+ * Test for {@link DecompositionSupport} features.
+ */
+ @Test
+ public void decompositionSupportTest() {
+ basicTest(new PivotedMatrixView(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ })));
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullMatrixTest() {
+ new CholeskyDecomposition(null);
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void wrongMatrixSizeTest() {
+ new CholeskyDecomposition(new DenseLocalOnHeapMatrix(2, 3));
+ }
+
+ /** */
+ @Test(expected = NonSymmetricMatrixException.class)
+ public void nonSymmetricMatrixTest() {
+ new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 10.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {-10.0d, -1.0d, 2.0d}
+ }));
+ }
+
+ /** */
+ @Test(expected = NonPositiveDefiniteMatrixException.class)
+ public void nonAbsPositiveMatrixTest() {
+ new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 0.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ }));
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void solveWrongVectorSizeTest() {
+ new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ })).solve(new DenseLocalOnHeapVector(2));
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void solveWrongMatrixSizeTest() {
+ new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ })).solve(new DenseLocalOnHeapMatrix(2, 3));
+ }
+
+ /** */
+ private void basicTest(Matrix m) {
+ // This decomposition is useful when dealing with systems of linear equations of the form
+ // m x = b where m is a Hermitian matrix.
+ // For such systems Cholesky decomposition provides
+ // more effective method of solving compared to LU decomposition.
+ // Suppose we want to solve system
+ // m x = b for various bs. Then after we computed Cholesky decomposition, we can feed various bs
+ // as a matrix of the form
+ // (b1, b2, ..., bm)
+ // to the method Cholesky::solve which returns solutions in the form
+ // (sol1, sol2, ..., solm)
+ CholeskyDecomposition dec = new CholeskyDecomposition(m);
+ assertEquals("Unexpected value for decomposition determinant.",
+ 4d, dec.getDeterminant(), 0d);
+
+ Matrix l = dec.getL();
+ Matrix lt = dec.getLT();
+
+ assertNotNull("Matrix l is expected to be not null.", l);
+ assertNotNull("Matrix lt is expected to be not null.", lt);
+
+ for (int row = 0; row < l.rowSize(); row++)
+ for (int col = 0; col < l.columnSize(); col++)
+ assertEquals("Unexpected value transposed matrix at (" + row + "," + col + ").",
+ l.get(row, col), lt.get(col, row), 0d);
+
+ Matrix bs = new DenseLocalOnHeapMatrix(new double[][] {
+ {4.0, -6.0, 7.0},
+ {1.0, 1.0, 1.0}
+ }).transpose();
+ Matrix sol = dec.solve(bs);
+
+ assertNotNull("Solution matrix is expected to be not null.", sol);
+ assertEquals("Solution rows are not as expected.", bs.rowSize(), sol.rowSize());
+ assertEquals("Solution columns are not as expected.", bs.columnSize(), sol.columnSize());
+
+ for (int i = 0; i < sol.columnSize(); i++)
+ assertNotNull("Solution matrix column is expected to be not null at index " + i, sol.viewColumn(i));
+
+ Vector b = new DenseLocalOnHeapVector(new double[] {4.0, -6.0, 7.0});
+ Vector solVec = dec.solve(b);
+
+ for (int idx = 0; idx < b.size(); idx++)
+ assertEquals("Unexpected value solution vector at " + idx,
+ b.get(idx), solVec.get(idx), 0d);
+
+ dec.destroy();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java
new file mode 100644
index 0000000..e4e7b15
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java
@@ -0,0 +1,193 @@
+/*
+ * 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.impls.matrix.DenseLocalOnHeapMatrix;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests for {@link EigenDecomposition}
+ */
+public class EigenDecompositionTest {
+ /** */
+ private static final double EPSILON = 1e-11;
+
+ /** */
+ @Test
+ public void testMatrixWithRealEigenvalues() {
+ test(new double[][] {
+ {1.0d, 0.0d, 0.0d, 0.0d},
+ {0.0d, 1.0d, 0.0d, 0.0d},
+ {0.0d, 0.0d, 2.0d, 0.0d},
+ {1.0d, 1.0d, 0.0d, 2.0d}},
+ new double[] {1, 2, 2, 1});
+ }
+
+ /** */
+ @Test
+ public void testSymmetricMatrix() {
+ EigenDecomposition decomposition = new EigenDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {1.0d, 0.0d, 0.0d, 1.0d},
+ {0.0d, 1.0d, 0.0d, 1.0d},
+ {0.0d, 0.0d, 2.0d, 0.0d},
+ {1.0d, 1.0d, 0.0d, 2.0d}}));
+
+ Matrix d = decomposition.getD();
+ Matrix v = decomposition.getV();
+
+ assertNotNull("Matrix d is expected to be not null.", d);
+ assertNotNull("Matrix v is expected to be not null.", v);
+
+ assertEquals("Unexpected rows in d matrix.", 4, d.rowSize());
+ assertEquals("Unexpected cols in d matrix.", 4, d.columnSize());
+
+ assertEquals("Unexpected rows in v matrix.", 4, v.rowSize());
+ assertEquals("Unexpected cols in v matrix.", 4, v.columnSize());
+
+ assertIsDiagonalNonZero(d);
+
+ decomposition.destroy();
+ }
+
+ /** */
+ @Test
+ public void testNonSquareMatrix() {
+ EigenDecomposition decomposition = new EigenDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {1.0d, 0.0d, 0.0d},
+ {0.0d, 1.0d, 0.0d},
+ {0.0d, 0.0d, 2.0d},
+ {1.0d, 1.0d, 0.0d}}));
+ // todo find out why decomposition of 3X4 matrix throws row index exception
+
+ Matrix d = decomposition.getD();
+ Matrix v = decomposition.getV();
+
+ assertNotNull("Matrix d is expected to be not null.", d);
+ assertNotNull("Matrix v is expected to be not null.", v);
+
+ assertEquals("Unexpected rows in d matrix.", 4, d.rowSize());
+ assertEquals("Unexpected cols in d matrix.", 4, d.columnSize());
+
+ assertEquals("Unexpected rows in v matrix.", 4, v.rowSize());
+ assertEquals("Unexpected cols in v matrix.", 3, v.columnSize());
+
+ assertIsDiagonal(d, true);
+
+ decomposition.destroy();
+ }
+
+ /** */
+ private void test(double[][] mRaw, double[] expRealEigenValues) {
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(mRaw);
+ EigenDecomposition decomposition = new EigenDecomposition(m);
+
+ Matrix d = decomposition.getD();
+ Matrix v = decomposition.getV();
+
+ assertIsDiagonalNonZero(d);
+
+ // check that d's diagonal consists of eigenvalues of m.
+ assertDiagonalConsistsOfEigenvalues(m, d, v);
+
+ // m = v d v^{-1} is equivalent to
+ // m v = v d
+ assertMatricesAreEqual(m.times(v), v.times(d));
+
+ assertEigenvalues(decomposition, expRealEigenValues);
+
+ decomposition.destroy();
+ }
+
+ /** */
+ private void assertEigenvalues(EigenDecomposition decomposition, double[] expRealEigenValues) {
+ Vector real = decomposition.getRealEigenValues();
+ Vector imag = decomposition.getImagEigenvalues();
+
+ assertEquals("Real values size differs from expected.", expRealEigenValues.length, real.size());
+ assertEquals("Imag values size differs from expected.", expRealEigenValues.length, imag.size());
+
+ for (int idx = 0; idx < expRealEigenValues.length; idx++) {
+ assertEquals("Real eigen value differs from expected at " + idx,
+ expRealEigenValues[idx], real.get(idx), 0d);
+
+ assertEquals("Imag eigen value differs from expected at " + idx,
+ 0d, imag.get(idx), 0d);
+ }
+
+ }
+
+ /** */
+ private void assertDiagonalConsistsOfEigenvalues(DenseLocalOnHeapMatrix m, Matrix d, Matrix v) {
+ int n = m.columnSize();
+ for (int i = 0; i < n; i++) {
+ Vector eigenVector = v.viewColumn(i);
+ double eigenVal = d.getX(i, i);
+ assertVectorsAreEqual(m.times(eigenVector), eigenVector.times(eigenVal));
+ }
+
+ }
+
+ /** */
+ private void assertMatricesAreEqual(Matrix exp, Matrix actual) {
+ assertTrue("The row sizes of matrices are not equal", exp.rowSize() == actual.rowSize());
+ assertTrue("The col sizes of matrices are not equal", exp.columnSize() == actual.columnSize());
+
+ // Since matrix is square, we need only one dimension
+ int n = exp.columnSize();
+
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < n; j++)
+ assertEquals("Values should be equal", exp.getX(i, j), actual.getX(i, j), EPSILON);
+ }
+
+ /** */
+ private void assertVectorsAreEqual(Vector exp, Vector actual) {
+ assertTrue("Vectors sizes are not equal", exp.size() == actual.size());
+
+ // Since matrix is square, we need only one dimension
+ int n = exp.size();
+
+ for (int i = 0; i < n; i++)
+ assertEquals("Values should be equal", exp.getX(i), actual.getX(i), EPSILON);
+ }
+
+ /** */
+ private void assertIsDiagonalNonZero(Matrix m) {
+ assertIsDiagonal(m, false);
+ }
+
+ /** */
+ private void assertIsDiagonal(Matrix m, boolean zeroesAllowed) {
+ // Since matrix is square, we need only one dimension
+ int n = m.columnSize();
+
+ assertEquals("Diagonal matrix is not square", n, m.rowSize());
+
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < n; j++)
+ assertTrue("Matrix is not diagonal, violation at (" + i + "," + j + ")",
+ ((i == j) && (zeroesAllowed || m.getX(i, j) != 0))
+ || ((i != j) && m.getX(i, j) == 0));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java
new file mode 100644
index 0000000..0feb48f
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java
@@ -0,0 +1,250 @@
+/*
+ * 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;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests for {@link LUDecomposition}.
+ */
+public class LUDecompositionTest {
+ /** */
+ private Matrix testL;
+ /** */
+ private Matrix testU;
+ /** */
+ private Matrix testP;
+ /** */
+ private Matrix testMatrix;
+ /** */
+ private int[] rawPivot;
+
+ /** */
+ @Before
+ public void setUp() {
+ double[][] rawMatrix = new double[][] {
+ {2.0d, 1.0d, 1.0d, 0.0d},
+ {4.0d, 3.0d, 3.0d, 1.0d},
+ {8.0d, 7.0d, 9.0d, 5.0d},
+ {6.0d, 7.0d, 9.0d, 8.0d}};
+ double[][] rawL = {
+ {1.0d, 0.0d, 0.0d, 0.0d},
+ {3.0d / 4.0d, 1.0d, 0.0d, 0.0d},
+ {1.0d / 2.0d, -2.0d / 7.0d, 1.0d, 0.0d},
+ {1.0d / 4.0d, -3.0d / 7.0d, 1.0d / 3.0d, 1.0d}};
+ double[][] rawU = {
+ {8.0d, 7.0d, 9.0d, 5.0d},
+ {0.0d, 7.0d / 4.0d, 9.0d / 4.0d, 17.0d / 4.0d},
+ {0.0d, 0.0d, -6.0d / 7.0d, -2.0d / 7.0d},
+ {0.0d, 0.0d, 0.0d, 2.0d / 3.0d}};
+ double[][] rawP = new double[][] {
+ {0, 0, 1.0d, 0},
+ {0, 0, 0, 1.0d},
+ {0, 1.0d, 0, 0},
+ {1.0d, 0, 0, 0}};
+
+ rawPivot = new int[] {3, 4, 2, 1};
+
+ testMatrix = new DenseLocalOnHeapMatrix(rawMatrix);
+ testL = new DenseLocalOnHeapMatrix(rawL);
+ testU = new DenseLocalOnHeapMatrix(rawU);
+ testP = new DenseLocalOnHeapMatrix(rawP);
+ }
+
+ /** */
+ @Test
+ public void getL() throws Exception {
+ Matrix luDecompositionL = new LUDecomposition(testMatrix).getL();
+
+ assertEquals("Unexpected row size.", testL.rowSize(), luDecompositionL.rowSize());
+ assertEquals("Unexpected column size.", testL.columnSize(), luDecompositionL.columnSize());
+
+ for (int i = 0; i < testL.rowSize(); i++)
+ for (int j = 0; j < testL.columnSize(); j++)
+ assertEquals("Unexpected value at (" + i + "," + j + ").",
+ testL.getX(i, j), luDecompositionL.getX(i, j), 0.0000001d);
+
+ luDecompositionL.destroy();
+ }
+
+ /** */
+ @Test
+ public void getU() throws Exception {
+ Matrix luDecompositionU = new LUDecomposition(testMatrix).getU();
+
+ assertEquals("Unexpected row size.", testU.rowSize(), luDecompositionU.rowSize());
+ assertEquals("Unexpected column size.", testU.columnSize(), luDecompositionU.columnSize());
+
+ for (int i = 0; i < testU.rowSize(); i++)
+ for (int j = 0; j < testU.columnSize(); j++)
+ assertEquals("Unexpected value at (" + i + "," + j + ").",
+ testU.getX(i, j), luDecompositionU.getX(i, j), 0.0000001d);
+
+ luDecompositionU.destroy();
+ }
+
+ /** */
+ @Test
+ public void getP() throws Exception {
+ Matrix luDecompositionP = new LUDecomposition(testMatrix).getP();
+
+ assertEquals("Unexpected row size.", testP.rowSize(), luDecompositionP.rowSize());
+ assertEquals("Unexpected column size.", testP.columnSize(), luDecompositionP.columnSize());
+
+ for (int i = 0; i < testP.rowSize(); i++)
+ for (int j = 0; j < testP.columnSize(); j++)
+ assertEquals("Unexpected value at (" + i + "," + j + ").",
+ testP.getX(i, j), luDecompositionP.getX(i, j), 0.0000001d);
+
+ luDecompositionP.destroy();
+ }
+
+ /** */
+ @Test
+ public void getPivot() throws Exception {
+ Vector pivot = new LUDecomposition(testMatrix).getPivot();
+
+ assertEquals("Unexpected pivot size.", rawPivot.length, pivot.size());
+
+ for (int i = 0; i < testU.rowSize(); i++)
+ assertEquals("Unexpected value at " + i, rawPivot[i], (int)pivot.get(i) + 1);
+ }
+
+ /**
+ * Test for {@link DecompositionSupport} features.
+ */
+ @Test
+ public void decompositionSupportTest() {
+ LUDecomposition dec = new LUDecomposition(new PivotedMatrixView(testMatrix));
+ Matrix luDecompositionL = dec.getL();
+
+ assertEquals("Unexpected L row size.", testL.rowSize(), luDecompositionL.rowSize());
+ assertEquals("Unexpected L column size.", testL.columnSize(), luDecompositionL.columnSize());
+
+ for (int i = 0; i < testL.rowSize(); i++)
+ for (int j = 0; j < testL.columnSize(); j++)
+ assertEquals("Unexpected L value at (" + i + "," + j + ").",
+ testL.getX(i, j), luDecompositionL.getX(i, j), 0.0000001d);
+
+ Matrix luDecompositionU = dec.getU();
+
+ assertEquals("Unexpected U row size.", testU.rowSize(), luDecompositionU.rowSize());
+ assertEquals("Unexpected U column size.", testU.columnSize(), luDecompositionU.columnSize());
+
+ for (int i = 0; i < testU.rowSize(); i++)
+ for (int j = 0; j < testU.columnSize(); j++)
+ assertEquals("Unexpected U value at (" + i + "," + j + ").",
+ testU.getX(i, j), luDecompositionU.getX(i, j), 0.0000001d);
+
+ Matrix luDecompositionP = dec.getP();
+
+ assertEquals("Unexpected P row size.", testP.rowSize(), luDecompositionP.rowSize());
+ assertEquals("Unexpected P column size.", testP.columnSize(), luDecompositionP.columnSize());
+
+ for (int i = 0; i < testP.rowSize(); i++)
+ for (int j = 0; j < testP.columnSize(); j++)
+ assertEquals("Unexpected P value at (" + i + "," + j + ").",
+ testP.getX(i, j), luDecompositionP.getX(i, j), 0.0000001d);
+
+ dec.destroy();
+ }
+
+ /** */
+ @Test
+ public void singularDeterminant() throws Exception {
+ assertEquals("Unexpected determinant for singular matrix decomposition.",
+ 0d, new LUDecomposition(new DenseLocalOnHeapMatrix(2, 2)).determinant(), 0d);
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void solveVecWrongSize() throws Exception {
+ new LUDecomposition(testMatrix).solve(new DenseLocalOnHeapVector(testMatrix.rowSize() + 1));
+ }
+
+ /** */
+ @Test(expected = SingularMatrixException.class)
+ public void solveVecSingularMatrix() throws Exception {
+ new LUDecomposition(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()))
+ .solve(new DenseLocalOnHeapVector(testMatrix.rowSize()));
+ }
+
+ /** */
+ @Test
+ public void solveVec() throws Exception {
+ Vector sol = new LUDecomposition(new PivotedMatrixView(testMatrix))
+ .solve(new DenseLocalOnHeapVector(testMatrix.rowSize()));
+
+ assertEquals("Wrong solution vector size.", testMatrix.rowSize(), sol.size());
+
+ for (int i = 0; i < sol.size(); i++)
+ assertEquals("Unexpected value at index " + i, 0d, sol.getX(i), 0.0000001d);
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void solveMtxWrongSize() throws Exception {
+ new LUDecomposition(testMatrix).solve(
+ new DenseLocalOnHeapMatrix(testMatrix.rowSize() + 1, testMatrix.rowSize()));
+ }
+
+ /** */
+ @Test(expected = SingularMatrixException.class)
+ public void solveMtxSingularMatrix() throws Exception {
+ new LUDecomposition(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()))
+ .solve(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()));
+ }
+
+ /** */
+ @Test
+ public void solveMtx() throws Exception {
+ Matrix sol = new LUDecomposition(new PivotedMatrixView(testMatrix))
+ .solve(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()));
+
+ assertEquals("Wrong solution matrix row size.", testMatrix.rowSize(), sol.rowSize());
+
+ assertEquals("Wrong solution matrix column size.", testMatrix.rowSize(), sol.columnSize());
+
+ for (int row = 0; row < sol.rowSize(); row++)
+ for (int col = 0; col < sol.columnSize(); col++)
+ assertEquals("Unexpected P value at (" + row + "," + col + ").",
+ 0d, sol.getX(row, col), 0.0000001d);
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullMatrixTest() {
+ new LUDecomposition(null);
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void nonSquareMatrixTest() {
+ new LUDecomposition(new DenseLocalOnHeapMatrix(2, 3));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java
new file mode 100644
index 0000000..3bb92d1
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java
@@ -0,0 +1,139 @@
+/*
+ * 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.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class QRDecompositionTest {
+ /** */
+ @Test
+ public void basicTest() {
+ basicTest(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ }));
+ }
+
+ /**
+ * Test for {@link DecompositionSupport} features.
+ */
+ @Test
+ public void decompositionSupportTest() {
+ basicTest(new PivotedMatrixView(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ })));
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullMatrixTest() {
+ new QRDecomposition(null);
+ }
+
+ /** */
+ @Test(expected = IllegalArgumentException.class)
+ public void solveWrongMatrixSizeTest() {
+ new QRDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ })).solve(new DenseLocalOnHeapMatrix(2, 3));
+ }
+
+ /** */
+ private void basicTest(Matrix m) {
+ QRDecomposition dec = new QRDecomposition(m);
+ assertTrue("Unexpected value for full rank in decomposition " + dec, dec.hasFullRank());
+
+ Matrix q = dec.getQ();
+ Matrix r = dec.getR();
+
+ assertNotNull("Matrix q is expected to be not null.", q);
+ assertNotNull("Matrix r is expected to be not null.", r);
+
+ Matrix qSafeCp = safeCopy(q);
+
+ Matrix expIdentity = qSafeCp.times(qSafeCp.transpose());
+
+ final double delta = 0.0001;
+
+ for (int row = 0; row < expIdentity.rowSize(); row++)
+ for (int col = 0; col < expIdentity.columnSize(); col++)
+ assertEquals("Unexpected identity matrix value at (" + row + "," + col + ").",
+ row == col ? 1d : 0d, expIdentity.get(col, row), delta);
+
+ for (int row = 0; row < r.rowSize(); row++)
+ for (int col = 0; col < row - 1; col++)
+ assertEquals("Unexpected upper triangular matrix value at (" + row + "," + col + ").",
+ 0d, r.get(row, col), delta);
+
+ Matrix recomposed = qSafeCp.times(r);
+
+ for (int row = 0; row < m.rowSize(); row++)
+ for (int col = 0; col < m.columnSize(); col++)
+ assertEquals("Unexpected recomposed matrix value at (" + row + "," + col + ").",
+ m.get(row, col), recomposed.get(row, col), delta);
+
+ Matrix sol = dec.solve(new DenseLocalOnHeapMatrix(3, 10));
+ assertEquals("Unexpected rows in solution matrix.", 3, sol.rowSize());
+ assertEquals("Unexpected cols in solution matrix.", 10, sol.columnSize());
+
+ for (int row = 0; row < sol.rowSize(); row++)
+ for (int col = 0; col < sol.columnSize(); col++)
+ assertEquals("Unexpected solution matrix value at (" + row + "," + col + ").",
+ 0d, sol.get(row, col), delta);
+
+ dec.destroy();
+
+ QRDecomposition dec1 = new QRDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d},
+ {-1.0d, 2.0d},
+ {0.0d, -1.0d}
+ }));
+
+ assertTrue("Unexpected value for full rank in decomposition " + dec1, dec1.hasFullRank());
+
+ dec1.destroy();
+
+ QRDecomposition dec2 = new QRDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d, 0.0d},
+ {0.0d, -1.0d, 2.0d, 0.0d}
+ }));
+
+ assertTrue("Unexpected value for full rank in decomposition " + dec2, dec2.hasFullRank());
+
+ dec2.destroy();
+ }
+
+ /** */
+ private Matrix safeCopy(Matrix orig) {
+ return new DenseLocalOnHeapMatrix(orig.rowSize(), orig.columnSize()).assign(orig);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java
new file mode 100644
index 0000000..d0b89f8
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java
@@ -0,0 +1,120 @@
+/*
+ * 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.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class SingularValueDecompositionTest {
+ /** */
+ @Test
+ public void basicTest() {
+ basicTest(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ }));
+ }
+
+ /**
+ * Test for {@link DecompositionSupport} features.
+ */
+ @Test
+ public void decompositionSupportTest() {
+ basicTest(new PivotedMatrixView(new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ })));
+ }
+
+ /** */
+ @Test
+ public void rowsLessThanColumnsTest() {
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d}
+ });
+
+ SingularValueDecomposition dec = new SingularValueDecomposition(m);
+ assertEquals("Unexpected value for singular values size.",
+ 2, dec.getSingularValues().length);
+
+ Matrix s = dec.getS();
+ Matrix u = dec.getU();
+ Matrix v = dec.getV();
+ Matrix covariance = dec.getCovariance(0.5);
+
+ assertNotNull("Matrix s is expected to be not null.", s);
+ assertNotNull("Matrix u is expected to be not null.", u);
+ assertNotNull("Matrix v is expected to be not null.", v);
+ assertNotNull("Covariance matrix is expected to be not null.", covariance);
+
+ dec.destroy();
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullMatrixTest() {
+ new SingularValueDecomposition(null);
+ }
+
+ /** */
+ private void basicTest(Matrix m) {
+ SingularValueDecomposition dec = new SingularValueDecomposition(m);
+ assertEquals("Unexpected value for singular values size.",
+ 3, dec.getSingularValues().length);
+
+ Matrix s = dec.getS();
+ Matrix u = dec.getU();
+ Matrix v = dec.getV();
+ Matrix covariance = dec.getCovariance(0.5);
+
+ assertNotNull("Matrix s is expected to be not null.", s);
+ assertNotNull("Matrix u is expected to be not null.", u);
+ assertNotNull("Matrix v is expected to be not null.", v);
+ assertNotNull("Covariance matrix is expected to be not null.", covariance);
+
+ assertTrue("Decomposition cond is expected to be positive.", dec.cond() > 0);
+ assertTrue("Decomposition norm2 is expected to be positive.", dec.norm2() > 0);
+ assertEquals("Decomposition rank differs from expected.", 3, dec.rank());
+ assertEquals("Decomposition singular values size differs from expected.",
+ 3, dec.getSingularValues().length);
+
+ Matrix recomposed = (u.times(s).times(v.transpose()));
+
+ for (int row = 0; row < m.rowSize(); row++)
+ for (int col = 0; col < m.columnSize(); col++)
+ assertEquals("Unexpected recomposed matrix value at (" + row + "," + col + ").",
+ m.get(row, col), recomposed.get(row, col), 0.001);
+
+ for (int row = 0; row < covariance.rowSize(); row++)
+ for (int col = row + 1; col < covariance.columnSize(); col++)
+ assertEquals("Unexpected covariance matrix value at (" + row + "," + col + ").",
+ covariance.get(row, col), covariance.get(col, row), 0.001);
+
+ dec.destroy();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java
new file mode 100644
index 0000000..122c62e
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java
@@ -0,0 +1,88 @@
+/*
+ * 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;
+
+/**
+ * Collect constants for org.apache.ignite.math tests
+ */
+public interface MathTestConstants {
+ /** */
+ public double SECOND_ARG = 1d;
+
+ /**
+ * We assume that we will check calculation precision in other tests.
+ */
+ public double EXP_DELTA = 0.1d;
+
+ /** */
+ public String UNEXPECTED_VAL = "Unexpected value.";
+
+ /** */
+ public String NULL_GUID = "Null GUID.";
+
+ /** */
+ public String UNEXPECTED_GUID_VAL = "Unexpected GUID value.";
+
+ /** */
+ public String EMPTY_GUID = "Empty GUID.";
+
+ /** */
+ public String VALUES_SHOULD_BE_NOT_EQUALS = "Values should be not equals.";
+
+ /** */
+ public String NULL_VAL = "Null value.";
+
+ /** */
+ public String NULL_VALUES = "Null values.";
+
+ /** */
+ public String NOT_NULL_VAL = "Not null value.";
+
+ /** */
+ public double TEST_VAL = 1d;
+
+ /** */
+ public String VAL_NOT_EQUALS = "Values not equals.";
+
+ /** */
+ public String NO_NEXT_ELEMENT = "No next element.";
+
+ /** */
+ public int STORAGE_SIZE = 100;
+
+ /** */
+ public String WRONG_ATTRIBUTE_VAL = "Wrong attribute value.";
+
+ /** */
+ public String NULL_DATA_ELEMENT = "Null data element.";
+
+ /** */
+ public String WRONG_DATA_ELEMENT = "Wrong data element.";
+
+ /** */
+ public double NIL_DELTA = 0d;
+
+ /** */
+ public String NULL_DATA_STORAGE = "Null data storage.";
+
+ /** */
+ public String WRONG_DATA_SIZE = "Wrong data size.";
+
+ /** */
+ public String UNEXPECTED_DATA_VAL = "Unexpected data value.";
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java
new file mode 100644
index 0000000..8a6d077
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java
@@ -0,0 +1,369 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.internal.util.IgniteUtils;
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.IdentityValueMapper;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixKeyMapper;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.apache.ignite.testframework.junits.common.GridCommonTest;
+
+/**
+ * Tests for {@link CacheMatrix}.
+ */
+@GridCommonTest(group = "Distributed Models")
+public class CacheMatrixTest extends GridCommonAbstractTest {
+ /** Number of nodes in grid */
+ private static final int NODE_COUNT = 3;
+ /** Cache name. */
+ private static final String CACHE_NAME = "test-cache";
+ /** */
+ private static final String UNEXPECTED_ATTRIBUTE_VALUE = "Unexpected attribute value.";
+ /** Grid instance. */
+ private Ignite ignite;
+ /** Matrix rows */
+ private final int rows = MathTestConstants.STORAGE_SIZE;
+ /** Matrix cols */
+ private final int cols = MathTestConstants.STORAGE_SIZE;
+
+ /**
+ * Default constructor.
+ */
+ public CacheMatrixTest() {
+ super(false);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void beforeTestsStarted() throws Exception {
+ for (int i = 1; i <= NODE_COUNT; i++)
+ startGrid(i);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTestsStopped() throws Exception {
+ stopAllGrids();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override protected void beforeTest() throws Exception {
+ ignite = grid(NODE_COUNT);
+
+ ignite.configuration().setPeerClassLoadingEnabled(true);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void afterTest() throws Exception {
+ ignite.destroyCache(CACHE_NAME);
+ }
+
+ /** */
+ public void testGetSet() throws Exception {
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ for (int i = 0; i < rows; i++) {
+ for (int j = 0; j < cols; j++) {
+ double v = Math.random();
+ cacheMatrix.set(i, j, v);
+
+ assert Double.compare(v, cacheMatrix.get(i, j)) == 0;
+ assert Double.compare(v, cache.get(keyMapper.apply(i, j))) == 0;
+ }
+ }
+ }
+
+ /** */
+ public void testCopy() throws Exception {
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ fillMatrix(cacheMatrix);
+
+ try {
+ cacheMatrix.copy();
+
+ fail("UnsupportedOperationException expected");
+ }
+ catch (UnsupportedOperationException e) {
+ // No-op.
+ }
+ }
+
+ /** */
+ public void testLike() throws Exception {
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ try {
+ cacheMatrix.like(rows, cols);
+
+ fail("UnsupportedOperationException expected");
+ }
+ catch (UnsupportedOperationException e) {
+ // No-op.
+ }
+ }
+
+ /** */
+ public void testLikeVector() throws Exception {
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ try {
+ cacheMatrix.likeVector(cols);
+
+ fail("UnsupportedOperationException expected");
+ }
+ catch (UnsupportedOperationException e) {
+ // No-op.
+ }
+ }
+
+ /** */
+ public void testPlus() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ double plusVal = 2;
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ initMatrix(cacheMatrix);
+
+ cacheMatrix.plus(plusVal);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ assertEquals(plusVal, cacheMatrix.get(i, j));
+ }
+
+ /** */
+ public void testDivide() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ double initVal = 1;
+ double divVal = 2;
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ initMatrix(cacheMatrix);
+ cacheMatrix.assign(initVal);
+ cacheMatrix.divide(divVal);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ assertTrue(Double.compare(cacheMatrix.get(i, j), initVal / divVal) == 0);
+ }
+
+ /** */
+ public void testTimes() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ double initVal = 1;
+ double timVal = 2;
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ initMatrix(cacheMatrix);
+ cacheMatrix.assign(initVal);
+ cacheMatrix.times(timVal);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ assertTrue(Double.compare(cacheMatrix.get(i, j), initVal * timVal) == 0);
+ }
+
+ /** */
+ public void testSum() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ double initVal = 1;
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ double sum = 0;
+
+ initMatrix(cacheMatrix);
+ sum = cacheMatrix.sum();
+
+ assertTrue(Double.compare(sum, 0d) == 0);
+
+ cacheMatrix.assign(1d);
+ sum = cacheMatrix.sum();
+
+ assertTrue(Double.compare(sum, rows * cols) == 0);
+ }
+
+ /** */
+ public void testAssignSingleValue() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ double initVal = 1;
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ initMatrix(cacheMatrix);
+
+ cacheMatrix.assign(initVal);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ assertEquals(initVal, cacheMatrix.get(i, j));
+ }
+
+ /** */
+ public void testAssignArray() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ double[][] initVal = new double[rows][cols];
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ initVal[i][j] = Math.random();
+
+ cacheMatrix.assign(initVal);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ assertEquals(initVal[i][j], cacheMatrix.get(i, j));
+ }
+
+ /** */
+ public void testAttributes() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isSequentialAccess());
+ assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isDense());
+ assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isArrayBased());
+ assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isRandomAccess());
+ assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isDistributed());
+ }
+
+ /** */
+ public void testExternalization() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ final CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ ExternalizeTest<CacheMatrix<Integer, Double>> externalizeTest = new ExternalizeTest<CacheMatrix<Integer, Double>>() {
+
+ @Override public void externalizeTest() {
+ super.externalizeTest(cacheMatrix);
+ }
+ };
+
+ externalizeTest.externalizeTest();
+ }
+
+ /** */
+ public void testMinMax() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ final CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ cacheMatrix.set(i, j, i * rows + j);
+
+ assertEquals(0.0, cacheMatrix.minValue(), 0.0);
+ assertEquals(rows * cols - 1, cacheMatrix.maxValue(), 0.0);
+ }
+
+ /** */
+ public void testMap() {
+ IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
+
+ MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
+ IgniteCache<Integer, Double> cache = getCache();
+ final CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
+
+ initMatrix(cacheMatrix);
+
+ cacheMatrix.map(value -> value + 10);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ assertEquals(10.0, cacheMatrix.getX(i, j), 0.0);
+ }
+
+ /** */
+ private IgniteCache<Integer, Double> getCache() {
+ assert ignite != null;
+
+ CacheConfiguration cfg = new CacheConfiguration();
+ cfg.setName(CACHE_NAME);
+
+ IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(CACHE_NAME);
+
+ assert cache != null;
+ return cache;
+ }
+
+ /** */
+ private MatrixKeyMapper<Integer> getKeyMapper(final int rows, final int cols) {
+ return new MatrixKeyMapperForTests(rows, cols);
+ }
+
+ /** Init the given matrix by random values. */
+ private void fillMatrix(Matrix m) {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ m.set(i, j, Math.random());
+ }
+
+ /** Init the given matrix by zeros. */
+ private void initMatrix(Matrix m) {
+ for (int i = 0; i < m.rowSize(); i++)
+ for (int j = 0; j < m.columnSize(); j++)
+ m.set(i, j, 0d);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java
new file mode 100644
index 0000000..1f0537c
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java
@@ -0,0 +1,65 @@
+/*
+ * 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.matrix;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class DenseLocalOffHeapMatrixConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(0, 1), "invalid row parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(1, 0), "invalid col parameter");
+
+ //noinspection ConstantConditions
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(null), "null matrix parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(new double[][] {null, new double[1]}),
+ "null row in matrix");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ assertEquals("Expected number of rows, int parameters.", 1,
+ new DenseLocalOffHeapMatrix(1, 2).rowSize());
+
+ assertEquals("Expected number of rows, double[][] parameter.", 1,
+ new DenseLocalOffHeapMatrix(new double[][] {new double[2]}).rowSize());
+
+ assertEquals("Expected number of cols, int parameters.", 1,
+ new DenseLocalOffHeapMatrix(2, 1).columnSize());
+
+ assertEquals("Expected number of cols, double[][] parameter.", 1,
+ new DenseLocalOffHeapMatrix(new double[][] {new double[1], new double[1]}).columnSize());
+
+ double[][] data1 = new double[][] {{1, 2}, {3, 4}}, data2 = new double[][] {{1, 2}, {3, 5}};
+
+ assertTrue("Matrices with same values are expected to be equal",
+ new DenseLocalOffHeapMatrix(data1).equals(new DenseLocalOffHeapMatrix(data1)));
+
+ assertFalse("Matrices with same values are expected to be equal",
+ new DenseLocalOffHeapMatrix(data1).equals(new DenseLocalOffHeapMatrix(data2)));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java
new file mode 100644
index 0000000..0a25e31
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java
@@ -0,0 +1,71 @@
+/*
+ * 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.matrix;
+
+import java.util.function.Supplier;
+import org.apache.ignite.math.Matrix;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+/** */
+public class DenseLocalOnHeapMatrixConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ verifyAssertionError(() -> new DenseLocalOnHeapMatrix(0, 1), "invalid row parameter");
+
+ verifyAssertionError(() -> new DenseLocalOnHeapMatrix(1, 0), "invalid col parameter");
+
+ //noinspection ConstantConditions
+ verifyAssertionError(() -> new DenseLocalOnHeapMatrix(null), "null matrix parameter");
+
+ verifyAssertionError(() -> new DenseLocalOnHeapMatrix(new double[][] {null, new double[1]}),
+ "null row in matrix");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ assertEquals("Expected number of rows, int parameters.", 1,
+ new DenseLocalOnHeapMatrix(1, 2).rowSize());
+
+ assertEquals("Expected number of rows, double[][] parameter.", 1,
+ new DenseLocalOnHeapMatrix(new double[][] {new double[2]}).rowSize());
+
+ assertEquals("Expected number of cols, int parameters.", 1,
+ new DenseLocalOnHeapMatrix(2, 1).columnSize());
+
+ assertEquals("Expected number of cols, double[][] parameter.", 1,
+ new DenseLocalOnHeapMatrix(new double[][] {new double[1], new double[1]}).columnSize());
+ }
+
+ /** */
+ static void verifyAssertionError(Supplier<Matrix> ctor, String desc) {
+ try {
+ assertNotNull("Unexpected null matrix in " + desc, ctor.get());
+ }
+ catch (AssertionError ae) {
+ return;
+ }
+
+ fail("Expected error not caught in " + desc);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java
new file mode 100644
index 0000000..c0c2af7
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java
@@ -0,0 +1,209 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.ExternalizeTest;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Tests for {@link DiagonalMatrix}.
+ */
+public class DiagonalMatrixTest extends ExternalizeTest<DiagonalMatrix> {
+ /** */
+ public static final String UNEXPECTED_VALUE = "Unexpected value";
+
+ /** */
+ private DiagonalMatrix testMatrix;
+
+ /** */
+ @Before
+ public void setup() {
+ DenseLocalOnHeapMatrix parent = new DenseLocalOnHeapMatrix(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
+ fillMatrix(parent);
+ testMatrix = new DiagonalMatrix(parent);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void externalizeTest() {
+ externalizeTest(testMatrix);
+ }
+
+ /** */
+ @Test
+ public void testSetGetBasic() {
+ double testVal = 42;
+ for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++) {
+ testMatrix.set(i, i, testVal);
+
+ assertEquals(UNEXPECTED_VALUE + " at (" + i + "," + i + ")", testMatrix.get(i, i), testVal, 0d);
+ }
+
+ //noinspection EqualsWithItself
+ assertTrue("Matrix is expected to be equal to self.", testMatrix.equals(testMatrix));
+ //noinspection ObjectEqualsNull
+ assertFalse("Matrix is expected to be not equal to null.", testMatrix.equals(null));
+ }
+
+ /** */
+ @Test
+ public void testSetGet() {
+ verifyDiagonal(testMatrix);
+
+ final int size = MathTestConstants.STORAGE_SIZE;
+
+ for (Matrix m : new Matrix[] {
+ new DenseLocalOnHeapMatrix(size + 1, size),
+ new DenseLocalOnHeapMatrix(size, size + 1)}) {
+ fillMatrix(m);
+
+ verifyDiagonal(new DiagonalMatrix(m));
+ }
+
+ final double[] data = new double[size];
+
+ for (int i = 0; i < size; i++)
+ data[i] = 1 + i;
+
+ final Matrix m = new DiagonalMatrix(new DenseLocalOnHeapVector(data));
+
+ assertEquals("Rows in matrix constructed from vector", size, m.rowSize());
+ assertEquals("Cols in matrix constructed from vector", size, m.columnSize());
+
+ for (int i = 0; i < size; i++)
+ assertEquals(UNEXPECTED_VALUE + " at vector index " + i, data[i], m.get(i, i), 0d);
+
+ verifyDiagonal(m);
+
+ final Matrix m1 = new DiagonalMatrix(data);
+
+ assertEquals("Rows in matrix constructed from array", size, m1.rowSize());
+ assertEquals("Cols in matrix constructed from array", size, m1.columnSize());
+
+ for (int i = 0; i < size; i++)
+ assertEquals(UNEXPECTED_VALUE + " at array index " + i, data[i], m1.get(i, i), 0d);
+
+ verifyDiagonal(m1);
+ }
+
+ /** */
+ @Test
+ public void testConstant() {
+ final int size = MathTestConstants.STORAGE_SIZE;
+
+ for (double val : new double[] {-1.0, 0.0, 1.0}) {
+ Matrix m = new DiagonalMatrix(size, val);
+
+ assertEquals("Rows in matrix", size, m.rowSize());
+ assertEquals("Cols in matrix", size, m.columnSize());
+
+ for (int i = 0; i < size; i++)
+ assertEquals(UNEXPECTED_VALUE + " at index " + i, val, m.get(i, i), 0d);
+
+ verifyDiagonal(m, true);
+ }
+ }
+
+ /** */
+ @Test
+ public void testAttributes() {
+ assertTrue(UNEXPECTED_VALUE, testMatrix.rowSize() == MathTestConstants.STORAGE_SIZE);
+ assertTrue(UNEXPECTED_VALUE, testMatrix.columnSize() == MathTestConstants.STORAGE_SIZE);
+
+ assertFalse(UNEXPECTED_VALUE, testMatrix.isArrayBased());
+ assertTrue(UNEXPECTED_VALUE, testMatrix.isDense());
+ assertFalse(UNEXPECTED_VALUE, testMatrix.isDistributed());
+
+ assertEquals(UNEXPECTED_VALUE, testMatrix.isRandomAccess(), !testMatrix.isSequentialAccess());
+ assertTrue(UNEXPECTED_VALUE, testMatrix.isRandomAccess());
+ }
+
+ /** */
+ @Test
+ public void testNullParams() {
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DiagonalMatrix((Matrix)null), "Null Matrix parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DiagonalMatrix((Vector)null), "Null Vector parameter");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DiagonalMatrix((double[])null), "Null double[] parameter");
+ }
+
+ /** */
+ private void verifyDiagonal(Matrix m, boolean readonly) {
+ final int rows = m.rowSize(), cols = m.columnSize();
+
+ final String sizeDetails = "rows" + "X" + "cols " + rows + "X" + cols;
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++) {
+ final String details = " at (" + i + "," + j + "), " + sizeDetails;
+
+ final boolean diagonal = i == j;
+
+ final double old = m.get(i, j);
+
+ if (!diagonal)
+ assertEquals(UNEXPECTED_VALUE + details, 0, old, 0d);
+
+ final double exp = diagonal && !readonly ? old + 1 : old;
+
+ boolean expECaught = false;
+
+ try {
+ m.set(i, j, exp);
+ }
+ catch (UnsupportedOperationException uoe) {
+ if (diagonal && !readonly)
+ throw uoe;
+
+ expECaught = true;
+ }
+
+ if ((!diagonal || readonly) && !expECaught)
+ fail("Expected exception was not caught " + details);
+
+ assertEquals(UNEXPECTED_VALUE + details, exp, m.get(i, j), 0d);
+ }
+ }
+
+ /** */
+ private void verifyDiagonal(Matrix m) {
+ verifyDiagonal(m, false);
+ }
+
+ /** */
+ private void fillMatrix(Matrix m) {
+ final int rows = m.rowSize(), cols = m.columnSize();
+
+ boolean negative = false;
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ m.set(i, j, (negative = !negative) ? -(i * cols + j + 1) : i * cols + j + 1);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java
new file mode 100644
index 0000000..a5ac84a
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java
@@ -0,0 +1,113 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class FunctionMatrixConstructorTest {
+ /** */
+ @Test
+ public void invalidArgsTest() {
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(0, 1, (i, j) -> 0.0),
+ "Invalid row parameter.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 0, (i, j) -> 0.0),
+ "Invalid col parameter.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 1, null),
+ "Invalid func parameter.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(0, 1, (i, j) -> 0.0, null),
+ "Invalid row parameter, with setter func.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 0, (i, j) -> 0.0, null),
+ "Invalid col parameter, with setter func.");
+
+ DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 1, null, null),
+ "Invalid func parameter, with setter func.");
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ for (int rows : new int[] {1, 2, 3})
+ for (int cols : new int[] {1, 2, 3})
+ basicTest(rows, cols);
+
+ Matrix m = new FunctionMatrix(1, 1, (i, j) -> 1d);
+ //noinspection EqualsWithItself
+ assertTrue("Matrix is expected to be equal to self.", m.equals(m));
+ //noinspection ObjectEqualsNull
+ assertFalse("Matrix is expected to be not equal to null.", m.equals(null));
+ }
+
+ /** */
+ private void basicTest(int rows, int cols) {
+ double[][] data = new double[rows][cols];
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++)
+ data[row][col] = row * cols + row;
+
+ Matrix mReadOnly = new FunctionMatrix(rows, cols, (i, j) -> data[i][j]);
+
+ assertEquals("Rows in matrix.", rows, mReadOnly.rowSize());
+ assertEquals("Cols in matrix.", cols, mReadOnly.columnSize());
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++) {
+ assertEquals("Unexpected value at " + row + "x" + col, data[row][col], mReadOnly.get(row, col), 0d);
+
+ boolean expECaught = false;
+
+ try {
+ mReadOnly.set(row, col, 0.0);
+ }
+ catch (UnsupportedOperationException uoe) {
+ expECaught = true;
+ }
+
+ assertTrue("Expected exception wasn't thrown at " + row + "x" + col, expECaught);
+ }
+
+ Matrix m = new FunctionMatrix(rows, cols, (i, j) -> data[i][j], (i, j, val) -> data[i][j] = val);
+
+ assertEquals("Rows in matrix, with setter function.", rows, m.rowSize());
+ assertEquals("Cols in matrix, with setter function.", cols, m.columnSize());
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++) {
+ assertEquals("Unexpected value at " + row + "x" + col, data[row][col], m.get(row, col), 0d);
+
+ m.set(row, col, -data[row][col]);
+ }
+
+ for (int row = 0; row < rows; row++)
+ for (int col = 0; col < cols; col++)
+ assertEquals("Unexpected value set at " + row + "x" + col, -(row * cols + row), m.get(row, col), 0d);
+
+ assertTrue("Incorrect copy for empty matrix.", m.copy().equals(m));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java
new file mode 100644
index 0000000..c9fb390
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java
@@ -0,0 +1,156 @@
+/*
+ * 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.matrix;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import org.apache.ignite.math.Matrix;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Attribute tests for matrices.
+ *
+ * TODO: WIP
+ */
+public class MatrixAttributeTest {
+ /** */
+ private final List<MatrixAttributeTest.AttrCfg> attrCfgs = Arrays.asList(
+ new AttrCfg("isDense", Matrix::isDense,
+ DenseLocalOnHeapMatrix.class, DenseLocalOffHeapMatrix.class, RandomMatrix.class, DiagonalMatrix.class),
+ new AttrCfg("isArrayBased", Matrix::isArrayBased, DenseLocalOnHeapMatrix.class),
+ new AttrCfg("isDistributed", Matrix::isDistributed),
+ new AttrCfg("isRandomAccess", Matrix::isRandomAccess, DenseLocalOnHeapMatrix.class, DenseLocalOffHeapMatrix.class, RandomMatrix.class, DiagonalMatrix.class, SparseLocalOnHeapMatrix.class),
+ new AttrCfg("isSequentialAccess", Matrix::isSequentialAccess, DiagonalMatrix.class)
+ );
+
+ /** */
+ private final List<MatrixAttributeTest.Specification> specFixture = Arrays.asList(
+ new Specification(new DenseLocalOnHeapMatrix(1, 1)),
+ new Specification(new DenseLocalOffHeapMatrix(1, 1)),
+ new Specification(new RandomMatrix(1, 1)),
+ new Specification(new DiagonalMatrix(new double[] {1.0})),
+ new Specification(new FunctionMatrix(1, 1, (x, y) -> 1.0)),
+ new Specification(new SparseLocalOnHeapMatrix(1, 1))
+ );
+
+ /** */
+ @Test
+ public void isDenseTest() {
+ assertAttribute("isDense");
+ }
+
+ /** */
+ @Test
+ public void isArrayBasedTest() {
+ assertAttribute("isArrayBased");
+ }
+
+ /** */
+ @Test
+ public void isSequentialAccessTest() {
+ assertAttribute("isSequentialAccess");
+ }
+
+ /** */
+ @Test
+ public void isRandomAccessTest() {
+ assertAttribute("isRandomAccess");
+ }
+
+ /** */
+ @Test
+ public void isDistributedTest() {
+ assertAttribute("isDistributed");
+ }
+
+ /** */
+ private void assertAttribute(String name) {
+ final MatrixAttributeTest.AttrCfg attr = attrCfg(name);
+
+ for (MatrixAttributeTest.Specification spec : specFixture)
+ spec.verify(attr);
+ }
+
+ /** */
+ private MatrixAttributeTest.AttrCfg attrCfg(String name) {
+ for (MatrixAttributeTest.AttrCfg attr : attrCfgs)
+ if (attr.name.equals(name))
+ return attr;
+
+ throw new IllegalArgumentException("Undefined attribute " + name);
+ }
+
+ /** See http://en.wikipedia.org/wiki/Specification_pattern */
+ private static class Specification {
+ /** */
+ private final Matrix m;
+ /** */
+ private final Class<? extends Matrix> underlyingType;
+ /** */
+ private final List<String> attrsFromUnderlying;
+ /** */
+ final String desc;
+
+ /** */
+ Specification(Matrix m, Class<? extends Matrix> underlyingType, String... attrsFromUnderlying) {
+ this.m = m;
+ this.underlyingType = underlyingType;
+ this.attrsFromUnderlying = Arrays.asList(attrsFromUnderlying);
+ final Class<? extends Matrix> clazz = m.getClass();
+ desc = clazz.getSimpleName() + (clazz.equals(underlyingType)
+ ? "" : " (underlying type " + underlyingType.getSimpleName() + ")");
+ }
+
+ /** */
+ Specification(Matrix m) {
+ this(m, m.getClass());
+ }
+
+ /** */
+ void verify(MatrixAttributeTest.AttrCfg attr) {
+ final boolean obtained = attr.obtain.apply(m);
+
+ final Class<? extends Matrix> typeToCheck
+ = attrsFromUnderlying.contains(attr.name) ? underlyingType : m.getClass();
+
+ final boolean exp = attr.trueInTypes.contains(typeToCheck);
+
+ assertEquals("Unexpected " + attr.name + " value for " + desc, exp, obtained);
+ }
+ }
+
+ /** */
+ private static class AttrCfg {
+ /** */
+ final String name;
+ /** */
+ final Function<Matrix, Boolean> obtain;
+ /** */
+ final List<Class> trueInTypes;
+
+ /** */
+ AttrCfg(String name, Function<Matrix, Boolean> obtain, Class... trueInTypes) {
+ this.name = name;
+ this.obtain = obtain;
+ this.trueInTypes = Arrays.asList(trueInTypes);
+ }
+ }
+}
[17/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/TracerTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/TracerTest.java b/modules/math/src/test/java/org/apache/ignite/math/TracerTest.java
deleted file mode 100644
index 35d2f60..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/TracerTest.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * 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;
-
-import java.awt.Color;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-import java.util.Optional;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.junit.Test;
-
-import static java.nio.file.Files.createTempFile;
-import static org.junit.Assert.assertEquals;
-
-/**
- * Tests for {@link Tracer}.
- */
-public class TracerTest {
- /** */ private static final String DEFAULT_FORMAT = "%.10f";
- /** */ private static final double DEFAULT_DELTA = 0.000000001d;
-
- /**
- * Color mapper that maps [0, 1] range into three distinct RGB segments.
- */
- private static final Tracer.ColorMapper COLOR_MAPPER = new Tracer.ColorMapper() {
- /** {@inheritDoc} */
- @Override public Color apply(Double d) {
- if (d <= 0.33)
- return Color.RED;
- else if (d <= 0.66)
- return Color.GREEN;
- else
- return Color.BLUE;
- }
- };
-
- /**
- * @param size Vector size.
- */
- private Vector makeRandomVector(int size) {
- DenseLocalOnHeapVector vec = new DenseLocalOnHeapVector(size);
-
- vec.assign((idx) -> Math.random());
-
- return vec;
- }
-
- /**
- * @param rows Amount of rows in matrix.
- * @param cols Amount of columns in matrix.
- */
- private Matrix makeRandomMatrix(int rows, int cols) {
- DenseLocalOnHeapMatrix mtx = new DenseLocalOnHeapMatrix(rows, cols);
-
- // Missing assign(f)?
- mtx.map((d) -> Math.random());
-
- return mtx;
- }
-
- /**
- *
- */
- @Test
- public void testAsciiVectorTracer() {
- Vector vec = makeRandomVector(20);
-
- Tracer.showAscii(vec);
- Tracer.showAscii(vec, "%2f");
- Tracer.showAscii(vec, "%.3g");
- }
-
- /**
- *
- */
- @Test
- public void testAsciiMatrixTracer() {
- Matrix mtx = makeRandomMatrix(10, 10);
-
- Tracer.showAscii(mtx);
- Tracer.showAscii(mtx, "%2f");
- Tracer.showAscii(mtx, "%.3g");
- }
-
- /**
- *
- */
- @Test
- public void testHtmlVectorTracer() throws IOException {
- Vector vec1 = makeRandomVector(1000);
-
- // Default color mapping.
- Tracer.showHtml(vec1);
-
- // Custom color mapping.
- Tracer.showHtml(vec1, COLOR_MAPPER);
-
- // Default color mapping with sorted vector.
- Tracer.showHtml(vec1.sort());
- }
-
- /**
- *
- */
- @Test
- public void testHtmlMatrixTracer() throws IOException {
- Matrix mtx1 = makeRandomMatrix(100, 100);
-
- // Custom color mapping.
- Tracer.showHtml(mtx1, COLOR_MAPPER);
-
- Matrix mtx2 = new DenseLocalOnHeapMatrix(100, 100);
-
- double MAX = (double)(mtx2.rowSize() * mtx2.columnSize());
-
- mtx2.assign((x, y) -> (double)(x * y) / MAX);
-
- Tracer.showHtml(mtx2);
- }
-
- /** */
- @Test
- public void testWriteVectorToCSVFile() throws IOException {
- DenseLocalOnHeapVector vector = new DenseLocalOnHeapVector(MathTestConstants.STORAGE_SIZE);
-
- for (int i = 0; i < vector.size(); i++)
- vector.set(i, Math.random());
-
- Path file = createTempFile("vector", ".csv");
-
- Tracer.saveAsCsv(vector, DEFAULT_FORMAT, file.toString());
-
- System.out.println("Vector exported: " + file.getFileName());
-
- List<String> strings = Files.readAllLines(file);
- Optional<String> reduce = strings.stream().reduce((s1, s2) -> s1 + s2);
- String[] csvVals = reduce.get().split(",");
-
- for (int i = 0; i < vector.size(); i++) {
- Double csvVal = Double.valueOf(csvVals[i]);
-
- assertEquals("Unexpected value.", csvVal, vector.get(i), DEFAULT_DELTA);
- }
-
- Files.deleteIfExists(file);
- }
-
- /** */
- @Test
- public void testWriteMatrixToCSVFile() throws IOException {
- DenseLocalOnHeapMatrix matrix = new DenseLocalOnHeapMatrix(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
-
- for (int i = 0; i < matrix.rowSize(); i++)
- for (int j = 0; j < matrix.columnSize(); j++)
- matrix.set(i, j, Math.random());
-
- Path file = createTempFile("matrix", ".csv");
-
- Tracer.saveAsCsv(matrix, DEFAULT_FORMAT, file.toString());
-
- System.out.println("Matrix exported: " + file.getFileName());
-
- List<String> strings = Files.readAllLines(file);
- Optional<String> reduce = strings.stream().reduce((s1, s2) -> s1 + s2);
- String[] csvVals = reduce.get().split(",");
-
- for (int i = 0; i < matrix.rowSize(); i++)
- for (int j = 0; j < matrix.columnSize(); j++) {
- Double csvVal = Double.valueOf(csvVals[i * matrix.rowSize() + j]);
-
- assertEquals("Unexpected value.", csvVal, matrix.get(i, j), DEFAULT_DELTA);
- }
-
- Files.deleteIfExists(file);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java b/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java
deleted file mode 100644
index 4c3718a..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * 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.benchmark;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.Locale;
-import java.util.TimeZone;
-
-/** Refer {@link MathBenchmarkSelfTest} for usage examples. */
-class MathBenchmark {
- /** */
- private final boolean outputToConsole;
-
- /** */
- private final String benchmarkName;
-
- /** */
- private final int measurementTimes;
-
- /** */
- private final int warmUpTimes;
-
- /** */
- private final String tag;
-
- /** */
- private final String comments;
-
- /** Constructor strictly for use within this class. */
- private MathBenchmark(String benchmarkName, boolean outputToConsole, int measurementTimes, int warmUpTimes,
- String tag, String comments) {
- this.benchmarkName = benchmarkName;
- this.outputToConsole = outputToConsole;
- this.measurementTimes = measurementTimes;
- this.warmUpTimes = warmUpTimes;
- this.tag = tag;
- this.comments = comments;
- validate();
- }
-
- /**
- * Benchmark with specified name and default parameters, in particular, default output file.
- *
- * @param benchmarkName name
- */
- MathBenchmark(String benchmarkName) {
- this(benchmarkName, false, 100, 1, "", "");
- }
-
- /**
- * Executes the code using config of this benchmark.
- *
- * @param code code to execute
- * @throws Exception if something goes wrong
- */
- void execute(BenchmarkCode code) throws Exception {
- System.out.println("Started benchmark [" + benchmarkName + "].");
-
- for (int cnt = 0; cnt < warmUpTimes; cnt++)
- code.call();
-
- final long start = System.currentTimeMillis();
-
- for (int cnt = 0; cnt < measurementTimes; cnt++)
- code.call();
-
- final long end = System.currentTimeMillis();
-
- writeResults(formatResults(start, end));
-
- System.out.println("Finished benchmark [" + benchmarkName + "].");
- }
-
- /**
- * Set optional output mode for using stdout.
- *
- * @return configured benchmark
- */
- MathBenchmark outputToConsole() {
- return new MathBenchmark(benchmarkName, true, measurementTimes, warmUpTimes, tag, comments);
- }
-
- /**
- * Set optional measurement times.
- *
- * @param param times
- * @return configured benchmark
- */
- MathBenchmark measurementTimes(int param) {
- return new MathBenchmark(benchmarkName, outputToConsole, param, warmUpTimes, tag, comments);
- }
-
- /**
- * Set optional warm-up times.
- *
- * @param param times
- * @return configured benchmark
- */
- MathBenchmark warmUpTimes(int param) {
- return new MathBenchmark(benchmarkName, outputToConsole, measurementTimes, param, tag, comments);
- }
-
- /**
- * Set optional tag to help filtering specific kind of benchmark results.
- *
- * @param param name
- * @return configured benchmark
- */
- MathBenchmark tag(String param) {
- return new MathBenchmark(benchmarkName, outputToConsole, measurementTimes, warmUpTimes, param, comments);
- }
-
- /**
- * Set optional comments.
- *
- * @param param name
- * @return configured benchmark
- */
- MathBenchmark comments(String param) {
- return new MathBenchmark(benchmarkName, outputToConsole, measurementTimes, warmUpTimes, tag, param);
- }
-
- /** */
- private void writeResults(String results) throws Exception {
- if (outputToConsole) {
- System.out.println(results);
-
- return;
- }
-
- new ResultsWriter().append(results);
- }
-
- /** */
- private String formatResults(long start, long end) {
- final String delim = ",";
-
- assert !formatDouble(1000_000_001.1).contains(delim) : "Formatted results contain [" + delim + "].";
-
- final String ts = formatTs(start);
-
- assert !ts.contains(delim) : "Formatted timestamp contains [" + delim + "].";
-
- return benchmarkName +
- delim +
- ts + // IMPL NOTE timestamp
- delim +
- formatDouble((double)(end - start) / measurementTimes) +
- delim +
- measurementTimes +
- delim +
- warmUpTimes +
- delim +
- tag +
- delim +
- comments;
- }
-
- /** */
- private String formatDouble(double val) {
- return String.format(Locale.US, "%f", val);
- }
-
- /** */
- private String formatTs(long ts) {
- final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");
-
- sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
-
- return sdf.format(new Date(ts));
- }
-
- /** */
- private void validate() {
- if (benchmarkName == null || benchmarkName.isEmpty())
- throw new IllegalArgumentException("Invalid benchmark name: [" + benchmarkName + "].");
-
- if (measurementTimes < 1)
- throw new IllegalArgumentException("Invalid measurement times: [" + measurementTimes + "].");
- }
-
- /** */
- interface BenchmarkCode {
- // todo find out why Callable<Void> failed to work here
-
- /** */
- void call() throws Exception;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java b/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java
deleted file mode 100644
index 7a86461..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * 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.benchmark;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class MathBenchmarkSelfTest {
- /** */
- @Test
- @Ignore("Benchmark tests are intended only for manual execution")
- public void demoTest() throws Exception {
- for (int i = 0; i < 2; i++)
- new MathBenchmark("demo test")
- .outputToConsole() // IMPL NOTE this is to write output into console instead of a file
- .tag(null) // IMPL NOTE try null for tag, expect it to be formatted reasonably
- .comments(null) // IMPL NOTE try null for comments, expect it to be formatted reasonably
- .execute(() -> {
- double seed = 1.1;
-
- for (int cnt = 0; cnt < 1000; cnt++) {
- seed = Math.pow(seed, 2);
-
- assertTrue(seed > 0);
- }
- });
- }
-
- /** */
- @Test
- @Ignore("Benchmark tests are intended only for manual execution")
- public void configTest() throws Exception {
- new MathBenchmark("demo config test")
- .outputToConsole()
- .measurementTimes(2)
- .warmUpTimes(0)
- .tag("demo tag")
- .comments("demo comments")
- .execute(() -> System.out.println("config test"));
- }
-
- /** */
- @Test(expected = IllegalArgumentException.class)
- @Ignore("Benchmark tests are intended only for manual execution")
- public void emptyNameTest() throws Exception {
- new MathBenchmark("")
- .outputToConsole()
- .measurementTimes(1)
- .warmUpTimes(1)
- .tag("empty name test tag")
- .comments("empty name test comments")
- .execute(() -> System.out.println("empty name test"));
- }
-
- /** */
- @Test(expected = IllegalArgumentException.class)
- @Ignore("Benchmark tests are intended only for manual execution")
- public void nullDropboxPathTest() throws Exception {
- new ResultsWriter(null, "whatever", "whatever");
- }
-
- /** */
- @Test(expected = IllegalArgumentException.class)
- @Ignore("Benchmark tests are intended only for manual execution")
- public void nullDropboxUrlTest() throws Exception {
- new ResultsWriter("whatever", null, "whatever");
- }
-
- /** */
- @Test(expected = IllegalArgumentException.class)
- @Ignore("Benchmark tests are intended only for manual execution")
- public void nullDropboxTokenTest() throws Exception {
- new ResultsWriter("whatever", "whatever", null);
- }
-
- /** */
- @Test(expected = IllegalArgumentException.class)
- @Ignore("Benchmark tests are intended only for manual execution")
- public void nullResultsTest() throws Exception {
- new ResultsWriter("whatever", "whatever", "whatever").append(null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java b/modules/math/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java
deleted file mode 100644
index aeec156..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * 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.benchmark;
-
-import com.dropbox.core.DbxException;
-import com.dropbox.core.DbxRequestConfig;
-import com.dropbox.core.v2.DbxClientV2;
-import com.dropbox.core.v2.files.WriteMode;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
-import java.util.UUID;
-
-/** */
-class ResultsWriter {
- /** */
- private static final String DROPBOX_PATH
- = "/benchmarks/math.benchmark.results.csv";
-
- /** */
- private static final String DROPBOX_URL
- = "https://www.dropbox.com/s/r7tcle31r7gaty8/math.benchmark.results.csv";
-
- /** */
- private static final String ACCESS_TOKEN
- = "1MMmQjEyzGAAAAAAAAAAfDFrQ6oBPPi4NX-iU_VrgmXB2JDXqRHGa125cTkkEQ0V";
-
- /** */
- private final String dropboxPath;
- /** */
- private final String dropboxUrl;
- /** */
- private final String accessTok;
-
- /** */
- ResultsWriter(String dropboxPath, String dropboxUrl, String accessTok) {
- this.dropboxPath = dropboxPath;
- this.dropboxUrl = dropboxUrl;
- this.accessTok = accessTok;
-
- if (dropboxPath == null || dropboxUrl == null || accessTok == null)
- throw new IllegalArgumentException("Neither of dropbox path, URL, access token can be null.");
- }
-
- /** **/
- ResultsWriter() {
- this(DROPBOX_PATH, DROPBOX_URL, ACCESS_TOKEN);
- }
-
- /** */
- void append(String res) throws DbxException, IOException {
- if (res == null)
- throw new IllegalArgumentException("benchmark result is null");
-
- if (dropboxPath == null) {
- System.out.println(res);
-
- return;
- }
-
- append(res, client());
- }
-
- /** */
- private void append(String res, DbxClientV2 client) throws DbxException, IOException {
- File tmp = createTmpFile();
-
- try (FileOutputStream out = new FileOutputStream(tmp)) {
- client.files().download(dropboxPath).download(out);
- }
-
- writeResults(res, tmp);
-
- try (FileInputStream in = new FileInputStream(tmp)) {
- client.files().uploadBuilder(dropboxPath).withMode(WriteMode.OVERWRITE).uploadAndFinish(in);
- }
-
- if (!tmp.delete())
- System.out.println("Failed to delete " + tmp.getAbsolutePath());
-
- System.out.println("Uploaded benchmark results to: " + dropboxUrl);
- }
-
- /** */
- private void writeResults(String res, File tmp) throws IOException {
- final String unixLineSeparator = "\n";
-
- try (final PrintWriter writer = new PrintWriter(Files.newBufferedWriter(Paths.get(tmp.toURI()),
- StandardOpenOption.APPEND, StandardOpenOption.CREATE))) {
- writer.write(res + unixLineSeparator);
- }
- }
-
- /** */
- private File createTmpFile() throws IOException {
- File tmp = File.createTempFile(UUID.randomUUID().toString(), ".csv");
-
- tmp.deleteOnExit();
-
- return tmp;
- }
-
- /** */
- private DbxClientV2 client() {
- return new DbxClientV2(DbxRequestConfig.newBuilder("dropbox/MathBenchmark").build(), accessTok);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java b/modules/math/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java
deleted file mode 100644
index 1f7b204..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * 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.benchmark;
-
-import java.util.function.BiConsumer;
-import java.util.function.Function;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.junit.Ignore;
-import org.junit.Test;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-
-/** */
-public class VectorBenchmarkTest {
- // todo add benchmarks for other methods in Vector and for other types of Vector and Matrix
-
- /** */
- @Test
- @Ignore("Benchmark tests are intended only for manual execution")
- public void testDenseLocalOnHeapVector() throws Exception {
- benchmark("DenseLocalOnHeapVector basic mix", DenseLocalOnHeapVector::new, this::basicMix);
-
- benchmark("DenseLocalOnHeapVector fold map", DenseLocalOnHeapVector::new, this::foldMapMix);
- }
-
- /** */
- @Test
- @Ignore("Benchmark tests are intended only for manual execution")
- public void testDenseLocalOffHeapVector() throws Exception {
- benchmark("DenseLocalOffHeapVector basic mix", DenseLocalOffHeapVector::new, this::basicMix);
-
- benchmark("DenseLocalOffHeapVector fold map", DenseLocalOffHeapVector::new, this::foldMapMix);
- }
-
- /** */
- private void benchmark(String namePrefix, Function<Integer, Vector> constructor,
- BiConsumer<Integer, Function<Integer, Vector>> consumer) throws Exception {
- assertNotNull(namePrefix);
-
- new MathBenchmark(namePrefix + " small sizes").execute(() -> {
- for (int size : new int[] {2, 3, 4, 5, 6, 7})
- consumer.accept(size, constructor);
- });
-
- new MathBenchmark(namePrefix + " sizes powers of 2").execute(() -> {
- for (int power : new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14})
- consumer.accept(1 << power, constructor);
- });
-
- new MathBenchmark(namePrefix + " large sizes").execute(() -> {
- for (int power : new int[] {10, 12, 14, 16})
- for (int delta : new int[] {-1, 0, 1})
- consumer.accept((1 << power) + delta, constructor);
- });
-
- new MathBenchmark(namePrefix + " extra large sizes")
- .measurementTimes(10)
- .execute(() -> { // IMPL NOTE trying below with power 22 almost killed my IDEA and laptop
- for (int power : new int[] {17, 18, 19, 20, 21})
- for (int delta : new int[] {-1, 0}) // IMPL NOTE delta +1 is not intended for use here
- consumer.accept((1 << power) + delta, constructor);
- });
- }
-
- /** */
- private void basicMix(int size, Function<Integer, Vector> constructor) {
- final Vector v1 = constructor.apply(size), v2 = constructor.apply(size);
-
- for (int idx = 0; idx < size; idx++) {
- v1.set(idx, idx);
-
- v2.set(idx, size - idx);
- }
-
- assertNotNull(v1.sum());
-
- assertNotNull(v1.copy());
-
- assertFalse(v1.getLengthSquared() < 0);
-
- assertNotNull(v1.normalize());
-
- assertNotNull(v1.logNormalize());
-
- assertFalse(v1.getDistanceSquared(v2) < 0);
-
- assertNotNull(v1.divide(2));
-
- assertNotNull(v1.minus(v2));
-
- assertNotNull(v1.plus(v2));
-
- assertNotNull(v1.dot(v2));
-
- assertNotNull(v1.assign(v2));
-
- assertNotNull(v1.assign(1)); // IMPL NOTE this would better be last test for it sets all values the same
- }
-
- /** */
- private void foldMapMix(int size, Function<Integer, Vector> constructor) {
- final Vector v1 = constructor.apply(size), v2 = constructor.apply(size);
-
- for (int idx = 0; idx < size; idx++) {
- v1.set(idx, idx);
-
- v2.set(idx, size - idx);
- }
-
- assertNotNull(v1.map((val) -> (val + 1)));
-
- assertNotNull(v1.map(v2, (one, other) -> one + other / 2.0));
-
- assertNotNull(v1.map((val, val1) -> (val + val1), 2.0));
-
- assertNotNull(v1.foldMap((sum, val) -> (val + sum), (val) -> val, 0.0));
-
- assertNotNull(v1.foldMap(v2, (sum, val) -> (val + sum), (val1, val2) -> val1 + val2, 0.0));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/benchmark/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/benchmark/package-info.java b/modules/math/src/test/java/org/apache/ignite/math/benchmark/package-info.java
deleted file mode 100644
index cbf5d36..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/benchmark/package-info.java
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * 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.benchmark;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java b/modules/math/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java
deleted file mode 100644
index fa311e0..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/decompositions/CholeskyDecompositionTest.java
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * 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.NonPositiveDefiniteMatrixException;
-import org.apache.ignite.math.exceptions.NonSymmetricMatrixException;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-/** */
-public class CholeskyDecompositionTest {
- /** */
- @Test
- public void basicTest() {
- basicTest(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- }));
- }
-
- /**
- * Test for {@link DecompositionSupport} features.
- */
- @Test
- public void decompositionSupportTest() {
- basicTest(new PivotedMatrixView(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- })));
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullMatrixTest() {
- new CholeskyDecomposition(null);
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void wrongMatrixSizeTest() {
- new CholeskyDecomposition(new DenseLocalOnHeapMatrix(2, 3));
- }
-
- /** */
- @Test(expected = NonSymmetricMatrixException.class)
- public void nonSymmetricMatrixTest() {
- new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 10.0d},
- {-1.0d, 2.0d, -1.0d},
- {-10.0d, -1.0d, 2.0d}
- }));
- }
-
- /** */
- @Test(expected = NonPositiveDefiniteMatrixException.class)
- public void nonAbsPositiveMatrixTest() {
- new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 0.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- }));
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void solveWrongVectorSizeTest() {
- new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- })).solve(new DenseLocalOnHeapVector(2));
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void solveWrongMatrixSizeTest() {
- new CholeskyDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- })).solve(new DenseLocalOnHeapMatrix(2, 3));
- }
-
- /** */
- private void basicTest(Matrix m) {
- // This decomposition is useful when dealing with systems of linear equations of the form
- // m x = b where m is a Hermitian matrix.
- // For such systems Cholesky decomposition provides
- // more effective method of solving compared to LU decomposition.
- // Suppose we want to solve system
- // m x = b for various bs. Then after we computed Cholesky decomposition, we can feed various bs
- // as a matrix of the form
- // (b1, b2, ..., bm)
- // to the method Cholesky::solve which returns solutions in the form
- // (sol1, sol2, ..., solm)
- CholeskyDecomposition dec = new CholeskyDecomposition(m);
- assertEquals("Unexpected value for decomposition determinant.",
- 4d, dec.getDeterminant(), 0d);
-
- Matrix l = dec.getL();
- Matrix lt = dec.getLT();
-
- assertNotNull("Matrix l is expected to be not null.", l);
- assertNotNull("Matrix lt is expected to be not null.", lt);
-
- for (int row = 0; row < l.rowSize(); row++)
- for (int col = 0; col < l.columnSize(); col++)
- assertEquals("Unexpected value transposed matrix at (" + row + "," + col + ").",
- l.get(row, col), lt.get(col, row), 0d);
-
- Matrix bs = new DenseLocalOnHeapMatrix(new double[][] {
- {4.0, -6.0, 7.0},
- {1.0, 1.0, 1.0}
- }).transpose();
- Matrix sol = dec.solve(bs);
-
- assertNotNull("Solution matrix is expected to be not null.", sol);
- assertEquals("Solution rows are not as expected.", bs.rowSize(), sol.rowSize());
- assertEquals("Solution columns are not as expected.", bs.columnSize(), sol.columnSize());
-
- for (int i = 0; i < sol.columnSize(); i++)
- assertNotNull("Solution matrix column is expected to be not null at index " + i, sol.viewColumn(i));
-
- Vector b = new DenseLocalOnHeapVector(new double[] {4.0, -6.0, 7.0});
- Vector solVec = dec.solve(b);
-
- for (int idx = 0; idx < b.size(); idx++)
- assertEquals("Unexpected value solution vector at " + idx,
- b.get(idx), solVec.get(idx), 0d);
-
- dec.destroy();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java b/modules/math/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java
deleted file mode 100644
index e4e7b15..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/decompositions/EigenDecompositionTest.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * 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.impls.matrix.DenseLocalOnHeapMatrix;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Tests for {@link EigenDecomposition}
- */
-public class EigenDecompositionTest {
- /** */
- private static final double EPSILON = 1e-11;
-
- /** */
- @Test
- public void testMatrixWithRealEigenvalues() {
- test(new double[][] {
- {1.0d, 0.0d, 0.0d, 0.0d},
- {0.0d, 1.0d, 0.0d, 0.0d},
- {0.0d, 0.0d, 2.0d, 0.0d},
- {1.0d, 1.0d, 0.0d, 2.0d}},
- new double[] {1, 2, 2, 1});
- }
-
- /** */
- @Test
- public void testSymmetricMatrix() {
- EigenDecomposition decomposition = new EigenDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {1.0d, 0.0d, 0.0d, 1.0d},
- {0.0d, 1.0d, 0.0d, 1.0d},
- {0.0d, 0.0d, 2.0d, 0.0d},
- {1.0d, 1.0d, 0.0d, 2.0d}}));
-
- Matrix d = decomposition.getD();
- Matrix v = decomposition.getV();
-
- assertNotNull("Matrix d is expected to be not null.", d);
- assertNotNull("Matrix v is expected to be not null.", v);
-
- assertEquals("Unexpected rows in d matrix.", 4, d.rowSize());
- assertEquals("Unexpected cols in d matrix.", 4, d.columnSize());
-
- assertEquals("Unexpected rows in v matrix.", 4, v.rowSize());
- assertEquals("Unexpected cols in v matrix.", 4, v.columnSize());
-
- assertIsDiagonalNonZero(d);
-
- decomposition.destroy();
- }
-
- /** */
- @Test
- public void testNonSquareMatrix() {
- EigenDecomposition decomposition = new EigenDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {1.0d, 0.0d, 0.0d},
- {0.0d, 1.0d, 0.0d},
- {0.0d, 0.0d, 2.0d},
- {1.0d, 1.0d, 0.0d}}));
- // todo find out why decomposition of 3X4 matrix throws row index exception
-
- Matrix d = decomposition.getD();
- Matrix v = decomposition.getV();
-
- assertNotNull("Matrix d is expected to be not null.", d);
- assertNotNull("Matrix v is expected to be not null.", v);
-
- assertEquals("Unexpected rows in d matrix.", 4, d.rowSize());
- assertEquals("Unexpected cols in d matrix.", 4, d.columnSize());
-
- assertEquals("Unexpected rows in v matrix.", 4, v.rowSize());
- assertEquals("Unexpected cols in v matrix.", 3, v.columnSize());
-
- assertIsDiagonal(d, true);
-
- decomposition.destroy();
- }
-
- /** */
- private void test(double[][] mRaw, double[] expRealEigenValues) {
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(mRaw);
- EigenDecomposition decomposition = new EigenDecomposition(m);
-
- Matrix d = decomposition.getD();
- Matrix v = decomposition.getV();
-
- assertIsDiagonalNonZero(d);
-
- // check that d's diagonal consists of eigenvalues of m.
- assertDiagonalConsistsOfEigenvalues(m, d, v);
-
- // m = v d v^{-1} is equivalent to
- // m v = v d
- assertMatricesAreEqual(m.times(v), v.times(d));
-
- assertEigenvalues(decomposition, expRealEigenValues);
-
- decomposition.destroy();
- }
-
- /** */
- private void assertEigenvalues(EigenDecomposition decomposition, double[] expRealEigenValues) {
- Vector real = decomposition.getRealEigenValues();
- Vector imag = decomposition.getImagEigenvalues();
-
- assertEquals("Real values size differs from expected.", expRealEigenValues.length, real.size());
- assertEquals("Imag values size differs from expected.", expRealEigenValues.length, imag.size());
-
- for (int idx = 0; idx < expRealEigenValues.length; idx++) {
- assertEquals("Real eigen value differs from expected at " + idx,
- expRealEigenValues[idx], real.get(idx), 0d);
-
- assertEquals("Imag eigen value differs from expected at " + idx,
- 0d, imag.get(idx), 0d);
- }
-
- }
-
- /** */
- private void assertDiagonalConsistsOfEigenvalues(DenseLocalOnHeapMatrix m, Matrix d, Matrix v) {
- int n = m.columnSize();
- for (int i = 0; i < n; i++) {
- Vector eigenVector = v.viewColumn(i);
- double eigenVal = d.getX(i, i);
- assertVectorsAreEqual(m.times(eigenVector), eigenVector.times(eigenVal));
- }
-
- }
-
- /** */
- private void assertMatricesAreEqual(Matrix exp, Matrix actual) {
- assertTrue("The row sizes of matrices are not equal", exp.rowSize() == actual.rowSize());
- assertTrue("The col sizes of matrices are not equal", exp.columnSize() == actual.columnSize());
-
- // Since matrix is square, we need only one dimension
- int n = exp.columnSize();
-
- for (int i = 0; i < n; i++)
- for (int j = 0; j < n; j++)
- assertEquals("Values should be equal", exp.getX(i, j), actual.getX(i, j), EPSILON);
- }
-
- /** */
- private void assertVectorsAreEqual(Vector exp, Vector actual) {
- assertTrue("Vectors sizes are not equal", exp.size() == actual.size());
-
- // Since matrix is square, we need only one dimension
- int n = exp.size();
-
- for (int i = 0; i < n; i++)
- assertEquals("Values should be equal", exp.getX(i), actual.getX(i), EPSILON);
- }
-
- /** */
- private void assertIsDiagonalNonZero(Matrix m) {
- assertIsDiagonal(m, false);
- }
-
- /** */
- private void assertIsDiagonal(Matrix m, boolean zeroesAllowed) {
- // Since matrix is square, we need only one dimension
- int n = m.columnSize();
-
- assertEquals("Diagonal matrix is not square", n, m.rowSize());
-
- for (int i = 0; i < n; i++)
- for (int j = 0; j < n; j++)
- assertTrue("Matrix is not diagonal, violation at (" + i + "," + j + ")",
- ((i == j) && (zeroesAllowed || m.getX(i, j) != 0))
- || ((i != j) && m.getX(i, j) == 0));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java b/modules/math/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java
deleted file mode 100644
index 0feb48f..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/decompositions/LUDecompositionTest.java
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * 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;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/**
- * Tests for {@link LUDecomposition}.
- */
-public class LUDecompositionTest {
- /** */
- private Matrix testL;
- /** */
- private Matrix testU;
- /** */
- private Matrix testP;
- /** */
- private Matrix testMatrix;
- /** */
- private int[] rawPivot;
-
- /** */
- @Before
- public void setUp() {
- double[][] rawMatrix = new double[][] {
- {2.0d, 1.0d, 1.0d, 0.0d},
- {4.0d, 3.0d, 3.0d, 1.0d},
- {8.0d, 7.0d, 9.0d, 5.0d},
- {6.0d, 7.0d, 9.0d, 8.0d}};
- double[][] rawL = {
- {1.0d, 0.0d, 0.0d, 0.0d},
- {3.0d / 4.0d, 1.0d, 0.0d, 0.0d},
- {1.0d / 2.0d, -2.0d / 7.0d, 1.0d, 0.0d},
- {1.0d / 4.0d, -3.0d / 7.0d, 1.0d / 3.0d, 1.0d}};
- double[][] rawU = {
- {8.0d, 7.0d, 9.0d, 5.0d},
- {0.0d, 7.0d / 4.0d, 9.0d / 4.0d, 17.0d / 4.0d},
- {0.0d, 0.0d, -6.0d / 7.0d, -2.0d / 7.0d},
- {0.0d, 0.0d, 0.0d, 2.0d / 3.0d}};
- double[][] rawP = new double[][] {
- {0, 0, 1.0d, 0},
- {0, 0, 0, 1.0d},
- {0, 1.0d, 0, 0},
- {1.0d, 0, 0, 0}};
-
- rawPivot = new int[] {3, 4, 2, 1};
-
- testMatrix = new DenseLocalOnHeapMatrix(rawMatrix);
- testL = new DenseLocalOnHeapMatrix(rawL);
- testU = new DenseLocalOnHeapMatrix(rawU);
- testP = new DenseLocalOnHeapMatrix(rawP);
- }
-
- /** */
- @Test
- public void getL() throws Exception {
- Matrix luDecompositionL = new LUDecomposition(testMatrix).getL();
-
- assertEquals("Unexpected row size.", testL.rowSize(), luDecompositionL.rowSize());
- assertEquals("Unexpected column size.", testL.columnSize(), luDecompositionL.columnSize());
-
- for (int i = 0; i < testL.rowSize(); i++)
- for (int j = 0; j < testL.columnSize(); j++)
- assertEquals("Unexpected value at (" + i + "," + j + ").",
- testL.getX(i, j), luDecompositionL.getX(i, j), 0.0000001d);
-
- luDecompositionL.destroy();
- }
-
- /** */
- @Test
- public void getU() throws Exception {
- Matrix luDecompositionU = new LUDecomposition(testMatrix).getU();
-
- assertEquals("Unexpected row size.", testU.rowSize(), luDecompositionU.rowSize());
- assertEquals("Unexpected column size.", testU.columnSize(), luDecompositionU.columnSize());
-
- for (int i = 0; i < testU.rowSize(); i++)
- for (int j = 0; j < testU.columnSize(); j++)
- assertEquals("Unexpected value at (" + i + "," + j + ").",
- testU.getX(i, j), luDecompositionU.getX(i, j), 0.0000001d);
-
- luDecompositionU.destroy();
- }
-
- /** */
- @Test
- public void getP() throws Exception {
- Matrix luDecompositionP = new LUDecomposition(testMatrix).getP();
-
- assertEquals("Unexpected row size.", testP.rowSize(), luDecompositionP.rowSize());
- assertEquals("Unexpected column size.", testP.columnSize(), luDecompositionP.columnSize());
-
- for (int i = 0; i < testP.rowSize(); i++)
- for (int j = 0; j < testP.columnSize(); j++)
- assertEquals("Unexpected value at (" + i + "," + j + ").",
- testP.getX(i, j), luDecompositionP.getX(i, j), 0.0000001d);
-
- luDecompositionP.destroy();
- }
-
- /** */
- @Test
- public void getPivot() throws Exception {
- Vector pivot = new LUDecomposition(testMatrix).getPivot();
-
- assertEquals("Unexpected pivot size.", rawPivot.length, pivot.size());
-
- for (int i = 0; i < testU.rowSize(); i++)
- assertEquals("Unexpected value at " + i, rawPivot[i], (int)pivot.get(i) + 1);
- }
-
- /**
- * Test for {@link DecompositionSupport} features.
- */
- @Test
- public void decompositionSupportTest() {
- LUDecomposition dec = new LUDecomposition(new PivotedMatrixView(testMatrix));
- Matrix luDecompositionL = dec.getL();
-
- assertEquals("Unexpected L row size.", testL.rowSize(), luDecompositionL.rowSize());
- assertEquals("Unexpected L column size.", testL.columnSize(), luDecompositionL.columnSize());
-
- for (int i = 0; i < testL.rowSize(); i++)
- for (int j = 0; j < testL.columnSize(); j++)
- assertEquals("Unexpected L value at (" + i + "," + j + ").",
- testL.getX(i, j), luDecompositionL.getX(i, j), 0.0000001d);
-
- Matrix luDecompositionU = dec.getU();
-
- assertEquals("Unexpected U row size.", testU.rowSize(), luDecompositionU.rowSize());
- assertEquals("Unexpected U column size.", testU.columnSize(), luDecompositionU.columnSize());
-
- for (int i = 0; i < testU.rowSize(); i++)
- for (int j = 0; j < testU.columnSize(); j++)
- assertEquals("Unexpected U value at (" + i + "," + j + ").",
- testU.getX(i, j), luDecompositionU.getX(i, j), 0.0000001d);
-
- Matrix luDecompositionP = dec.getP();
-
- assertEquals("Unexpected P row size.", testP.rowSize(), luDecompositionP.rowSize());
- assertEquals("Unexpected P column size.", testP.columnSize(), luDecompositionP.columnSize());
-
- for (int i = 0; i < testP.rowSize(); i++)
- for (int j = 0; j < testP.columnSize(); j++)
- assertEquals("Unexpected P value at (" + i + "," + j + ").",
- testP.getX(i, j), luDecompositionP.getX(i, j), 0.0000001d);
-
- dec.destroy();
- }
-
- /** */
- @Test
- public void singularDeterminant() throws Exception {
- assertEquals("Unexpected determinant for singular matrix decomposition.",
- 0d, new LUDecomposition(new DenseLocalOnHeapMatrix(2, 2)).determinant(), 0d);
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void solveVecWrongSize() throws Exception {
- new LUDecomposition(testMatrix).solve(new DenseLocalOnHeapVector(testMatrix.rowSize() + 1));
- }
-
- /** */
- @Test(expected = SingularMatrixException.class)
- public void solveVecSingularMatrix() throws Exception {
- new LUDecomposition(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()))
- .solve(new DenseLocalOnHeapVector(testMatrix.rowSize()));
- }
-
- /** */
- @Test
- public void solveVec() throws Exception {
- Vector sol = new LUDecomposition(new PivotedMatrixView(testMatrix))
- .solve(new DenseLocalOnHeapVector(testMatrix.rowSize()));
-
- assertEquals("Wrong solution vector size.", testMatrix.rowSize(), sol.size());
-
- for (int i = 0; i < sol.size(); i++)
- assertEquals("Unexpected value at index " + i, 0d, sol.getX(i), 0.0000001d);
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void solveMtxWrongSize() throws Exception {
- new LUDecomposition(testMatrix).solve(
- new DenseLocalOnHeapMatrix(testMatrix.rowSize() + 1, testMatrix.rowSize()));
- }
-
- /** */
- @Test(expected = SingularMatrixException.class)
- public void solveMtxSingularMatrix() throws Exception {
- new LUDecomposition(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()))
- .solve(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()));
- }
-
- /** */
- @Test
- public void solveMtx() throws Exception {
- Matrix sol = new LUDecomposition(new PivotedMatrixView(testMatrix))
- .solve(new DenseLocalOnHeapMatrix(testMatrix.rowSize(), testMatrix.rowSize()));
-
- assertEquals("Wrong solution matrix row size.", testMatrix.rowSize(), sol.rowSize());
-
- assertEquals("Wrong solution matrix column size.", testMatrix.rowSize(), sol.columnSize());
-
- for (int row = 0; row < sol.rowSize(); row++)
- for (int col = 0; col < sol.columnSize(); col++)
- assertEquals("Unexpected P value at (" + row + "," + col + ").",
- 0d, sol.getX(row, col), 0.0000001d);
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullMatrixTest() {
- new LUDecomposition(null);
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void nonSquareMatrixTest() {
- new LUDecomposition(new DenseLocalOnHeapMatrix(2, 3));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java b/modules/math/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java
deleted file mode 100644
index 3bb92d1..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/decompositions/QRDecompositionTest.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * 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.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class QRDecompositionTest {
- /** */
- @Test
- public void basicTest() {
- basicTest(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- }));
- }
-
- /**
- * Test for {@link DecompositionSupport} features.
- */
- @Test
- public void decompositionSupportTest() {
- basicTest(new PivotedMatrixView(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- })));
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullMatrixTest() {
- new QRDecomposition(null);
- }
-
- /** */
- @Test(expected = IllegalArgumentException.class)
- public void solveWrongMatrixSizeTest() {
- new QRDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- })).solve(new DenseLocalOnHeapMatrix(2, 3));
- }
-
- /** */
- private void basicTest(Matrix m) {
- QRDecomposition dec = new QRDecomposition(m);
- assertTrue("Unexpected value for full rank in decomposition " + dec, dec.hasFullRank());
-
- Matrix q = dec.getQ();
- Matrix r = dec.getR();
-
- assertNotNull("Matrix q is expected to be not null.", q);
- assertNotNull("Matrix r is expected to be not null.", r);
-
- Matrix qSafeCp = safeCopy(q);
-
- Matrix expIdentity = qSafeCp.times(qSafeCp.transpose());
-
- final double delta = 0.0001;
-
- for (int row = 0; row < expIdentity.rowSize(); row++)
- for (int col = 0; col < expIdentity.columnSize(); col++)
- assertEquals("Unexpected identity matrix value at (" + row + "," + col + ").",
- row == col ? 1d : 0d, expIdentity.get(col, row), delta);
-
- for (int row = 0; row < r.rowSize(); row++)
- for (int col = 0; col < row - 1; col++)
- assertEquals("Unexpected upper triangular matrix value at (" + row + "," + col + ").",
- 0d, r.get(row, col), delta);
-
- Matrix recomposed = qSafeCp.times(r);
-
- for (int row = 0; row < m.rowSize(); row++)
- for (int col = 0; col < m.columnSize(); col++)
- assertEquals("Unexpected recomposed matrix value at (" + row + "," + col + ").",
- m.get(row, col), recomposed.get(row, col), delta);
-
- Matrix sol = dec.solve(new DenseLocalOnHeapMatrix(3, 10));
- assertEquals("Unexpected rows in solution matrix.", 3, sol.rowSize());
- assertEquals("Unexpected cols in solution matrix.", 10, sol.columnSize());
-
- for (int row = 0; row < sol.rowSize(); row++)
- for (int col = 0; col < sol.columnSize(); col++)
- assertEquals("Unexpected solution matrix value at (" + row + "," + col + ").",
- 0d, sol.get(row, col), delta);
-
- dec.destroy();
-
- QRDecomposition dec1 = new QRDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d},
- {-1.0d, 2.0d},
- {0.0d, -1.0d}
- }));
-
- assertTrue("Unexpected value for full rank in decomposition " + dec1, dec1.hasFullRank());
-
- dec1.destroy();
-
- QRDecomposition dec2 = new QRDecomposition(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d, 0.0d},
- {0.0d, -1.0d, 2.0d, 0.0d}
- }));
-
- assertTrue("Unexpected value for full rank in decomposition " + dec2, dec2.hasFullRank());
-
- dec2.destroy();
- }
-
- /** */
- private Matrix safeCopy(Matrix orig) {
- return new DenseLocalOnHeapMatrix(orig.rowSize(), orig.columnSize()).assign(orig);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java b/modules/math/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java
deleted file mode 100644
index d0b89f8..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/decompositions/SingularValueDecompositionTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * 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.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class SingularValueDecompositionTest {
- /** */
- @Test
- public void basicTest() {
- basicTest(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- }));
- }
-
- /**
- * Test for {@link DecompositionSupport} features.
- */
- @Test
- public void decompositionSupportTest() {
- basicTest(new PivotedMatrixView(new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- })));
- }
-
- /** */
- @Test
- public void rowsLessThanColumnsTest() {
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d}
- });
-
- SingularValueDecomposition dec = new SingularValueDecomposition(m);
- assertEquals("Unexpected value for singular values size.",
- 2, dec.getSingularValues().length);
-
- Matrix s = dec.getS();
- Matrix u = dec.getU();
- Matrix v = dec.getV();
- Matrix covariance = dec.getCovariance(0.5);
-
- assertNotNull("Matrix s is expected to be not null.", s);
- assertNotNull("Matrix u is expected to be not null.", u);
- assertNotNull("Matrix v is expected to be not null.", v);
- assertNotNull("Covariance matrix is expected to be not null.", covariance);
-
- dec.destroy();
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullMatrixTest() {
- new SingularValueDecomposition(null);
- }
-
- /** */
- private void basicTest(Matrix m) {
- SingularValueDecomposition dec = new SingularValueDecomposition(m);
- assertEquals("Unexpected value for singular values size.",
- 3, dec.getSingularValues().length);
-
- Matrix s = dec.getS();
- Matrix u = dec.getU();
- Matrix v = dec.getV();
- Matrix covariance = dec.getCovariance(0.5);
-
- assertNotNull("Matrix s is expected to be not null.", s);
- assertNotNull("Matrix u is expected to be not null.", u);
- assertNotNull("Matrix v is expected to be not null.", v);
- assertNotNull("Covariance matrix is expected to be not null.", covariance);
-
- assertTrue("Decomposition cond is expected to be positive.", dec.cond() > 0);
- assertTrue("Decomposition norm2 is expected to be positive.", dec.norm2() > 0);
- assertEquals("Decomposition rank differs from expected.", 3, dec.rank());
- assertEquals("Decomposition singular values size differs from expected.",
- 3, dec.getSingularValues().length);
-
- Matrix recomposed = (u.times(s).times(v.transpose()));
-
- for (int row = 0; row < m.rowSize(); row++)
- for (int col = 0; col < m.columnSize(); col++)
- assertEquals("Unexpected recomposed matrix value at (" + row + "," + col + ").",
- m.get(row, col), recomposed.get(row, col), 0.001);
-
- for (int row = 0; row < covariance.rowSize(); row++)
- for (int col = row + 1; col < covariance.columnSize(); col++)
- assertEquals("Unexpected covariance matrix value at (" + row + "," + col + ").",
- covariance.get(row, col), covariance.get(col, row), 0.001);
-
- dec.destroy();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java b/modules/math/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java
deleted file mode 100644
index 122c62e..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/MathTestConstants.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * 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;
-
-/**
- * Collect constants for org.apache.ignite.math tests
- */
-public interface MathTestConstants {
- /** */
- public double SECOND_ARG = 1d;
-
- /**
- * We assume that we will check calculation precision in other tests.
- */
- public double EXP_DELTA = 0.1d;
-
- /** */
- public String UNEXPECTED_VAL = "Unexpected value.";
-
- /** */
- public String NULL_GUID = "Null GUID.";
-
- /** */
- public String UNEXPECTED_GUID_VAL = "Unexpected GUID value.";
-
- /** */
- public String EMPTY_GUID = "Empty GUID.";
-
- /** */
- public String VALUES_SHOULD_BE_NOT_EQUALS = "Values should be not equals.";
-
- /** */
- public String NULL_VAL = "Null value.";
-
- /** */
- public String NULL_VALUES = "Null values.";
-
- /** */
- public String NOT_NULL_VAL = "Not null value.";
-
- /** */
- public double TEST_VAL = 1d;
-
- /** */
- public String VAL_NOT_EQUALS = "Values not equals.";
-
- /** */
- public String NO_NEXT_ELEMENT = "No next element.";
-
- /** */
- public int STORAGE_SIZE = 100;
-
- /** */
- public String WRONG_ATTRIBUTE_VAL = "Wrong attribute value.";
-
- /** */
- public String NULL_DATA_ELEMENT = "Null data element.";
-
- /** */
- public String WRONG_DATA_ELEMENT = "Wrong data element.";
-
- /** */
- public double NIL_DELTA = 0d;
-
- /** */
- public String NULL_DATA_STORAGE = "Null data storage.";
-
- /** */
- public String WRONG_DATA_SIZE = "Wrong data size.";
-
- /** */
- public String UNEXPECTED_DATA_VAL = "Unexpected data value.";
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java
deleted file mode 100644
index 8a6d077..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/CacheMatrixTest.java
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.internal.util.IgniteUtils;
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.IdentityValueMapper;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixKeyMapper;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
-import org.apache.ignite.testframework.junits.common.GridCommonTest;
-
-/**
- * Tests for {@link CacheMatrix}.
- */
-@GridCommonTest(group = "Distributed Models")
-public class CacheMatrixTest extends GridCommonAbstractTest {
- /** Number of nodes in grid */
- private static final int NODE_COUNT = 3;
- /** Cache name. */
- private static final String CACHE_NAME = "test-cache";
- /** */
- private static final String UNEXPECTED_ATTRIBUTE_VALUE = "Unexpected attribute value.";
- /** Grid instance. */
- private Ignite ignite;
- /** Matrix rows */
- private final int rows = MathTestConstants.STORAGE_SIZE;
- /** Matrix cols */
- private final int cols = MathTestConstants.STORAGE_SIZE;
-
- /**
- * Default constructor.
- */
- public CacheMatrixTest() {
- super(false);
- }
-
- /** {@inheritDoc} */
- @Override protected void beforeTestsStarted() throws Exception {
- for (int i = 1; i <= NODE_COUNT; i++)
- startGrid(i);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTestsStopped() throws Exception {
- stopAllGrids();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override protected void beforeTest() throws Exception {
- ignite = grid(NODE_COUNT);
-
- ignite.configuration().setPeerClassLoadingEnabled(true);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTest() throws Exception {
- ignite.destroyCache(CACHE_NAME);
- }
-
- /** */
- public void testGetSet() throws Exception {
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- for (int i = 0; i < rows; i++) {
- for (int j = 0; j < cols; j++) {
- double v = Math.random();
- cacheMatrix.set(i, j, v);
-
- assert Double.compare(v, cacheMatrix.get(i, j)) == 0;
- assert Double.compare(v, cache.get(keyMapper.apply(i, j))) == 0;
- }
- }
- }
-
- /** */
- public void testCopy() throws Exception {
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- fillMatrix(cacheMatrix);
-
- try {
- cacheMatrix.copy();
-
- fail("UnsupportedOperationException expected");
- }
- catch (UnsupportedOperationException e) {
- // No-op.
- }
- }
-
- /** */
- public void testLike() throws Exception {
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- try {
- cacheMatrix.like(rows, cols);
-
- fail("UnsupportedOperationException expected");
- }
- catch (UnsupportedOperationException e) {
- // No-op.
- }
- }
-
- /** */
- public void testLikeVector() throws Exception {
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- try {
- cacheMatrix.likeVector(cols);
-
- fail("UnsupportedOperationException expected");
- }
- catch (UnsupportedOperationException e) {
- // No-op.
- }
- }
-
- /** */
- public void testPlus() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- double plusVal = 2;
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- initMatrix(cacheMatrix);
-
- cacheMatrix.plus(plusVal);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- assertEquals(plusVal, cacheMatrix.get(i, j));
- }
-
- /** */
- public void testDivide() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- double initVal = 1;
- double divVal = 2;
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- initMatrix(cacheMatrix);
- cacheMatrix.assign(initVal);
- cacheMatrix.divide(divVal);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- assertTrue(Double.compare(cacheMatrix.get(i, j), initVal / divVal) == 0);
- }
-
- /** */
- public void testTimes() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- double initVal = 1;
- double timVal = 2;
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- initMatrix(cacheMatrix);
- cacheMatrix.assign(initVal);
- cacheMatrix.times(timVal);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- assertTrue(Double.compare(cacheMatrix.get(i, j), initVal * timVal) == 0);
- }
-
- /** */
- public void testSum() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- double initVal = 1;
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- double sum = 0;
-
- initMatrix(cacheMatrix);
- sum = cacheMatrix.sum();
-
- assertTrue(Double.compare(sum, 0d) == 0);
-
- cacheMatrix.assign(1d);
- sum = cacheMatrix.sum();
-
- assertTrue(Double.compare(sum, rows * cols) == 0);
- }
-
- /** */
- public void testAssignSingleValue() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- double initVal = 1;
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- initMatrix(cacheMatrix);
-
- cacheMatrix.assign(initVal);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- assertEquals(initVal, cacheMatrix.get(i, j));
- }
-
- /** */
- public void testAssignArray() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- double[][] initVal = new double[rows][cols];
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- initVal[i][j] = Math.random();
-
- cacheMatrix.assign(initVal);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- assertEquals(initVal[i][j], cacheMatrix.get(i, j));
- }
-
- /** */
- public void testAttributes() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isSequentialAccess());
- assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isDense());
- assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isArrayBased());
- assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isRandomAccess());
- assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, cacheMatrix.isDistributed());
- }
-
- /** */
- public void testExternalization() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- final CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- ExternalizeTest<CacheMatrix<Integer, Double>> externalizeTest = new ExternalizeTest<CacheMatrix<Integer, Double>>() {
-
- @Override public void externalizeTest() {
- super.externalizeTest(cacheMatrix);
- }
- };
-
- externalizeTest.externalizeTest();
- }
-
- /** */
- public void testMinMax() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- final CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- cacheMatrix.set(i, j, i * rows + j);
-
- assertEquals(0.0, cacheMatrix.minValue(), 0.0);
- assertEquals(rows * cols - 1, cacheMatrix.maxValue(), 0.0);
- }
-
- /** */
- public void testMap() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- MatrixKeyMapper<Integer> keyMapper = getKeyMapper(rows, cols);
- IgniteCache<Integer, Double> cache = getCache();
- final CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(rows, cols, cache, keyMapper, new IdentityValueMapper());
-
- initMatrix(cacheMatrix);
-
- cacheMatrix.map(value -> value + 10);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- assertEquals(10.0, cacheMatrix.getX(i, j), 0.0);
- }
-
- /** */
- private IgniteCache<Integer, Double> getCache() {
- assert ignite != null;
-
- CacheConfiguration cfg = new CacheConfiguration();
- cfg.setName(CACHE_NAME);
-
- IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(CACHE_NAME);
-
- assert cache != null;
- return cache;
- }
-
- /** */
- private MatrixKeyMapper<Integer> getKeyMapper(final int rows, final int cols) {
- return new MatrixKeyMapperForTests(rows, cols);
- }
-
- /** Init the given matrix by random values. */
- private void fillMatrix(Matrix m) {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- m.set(i, j, Math.random());
- }
-
- /** Init the given matrix by zeros. */
- private void initMatrix(Matrix m) {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- m.set(i, j, 0d);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java
deleted file mode 100644
index 1f0537c..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrixConstructorTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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.matrix;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class DenseLocalOffHeapMatrixConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(0, 1), "invalid row parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(1, 0), "invalid col parameter");
-
- //noinspection ConstantConditions
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(null), "null matrix parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DenseLocalOffHeapMatrix(new double[][] {null, new double[1]}),
- "null row in matrix");
- }
-
- /** */
- @Test
- public void basicTest() {
- assertEquals("Expected number of rows, int parameters.", 1,
- new DenseLocalOffHeapMatrix(1, 2).rowSize());
-
- assertEquals("Expected number of rows, double[][] parameter.", 1,
- new DenseLocalOffHeapMatrix(new double[][] {new double[2]}).rowSize());
-
- assertEquals("Expected number of cols, int parameters.", 1,
- new DenseLocalOffHeapMatrix(2, 1).columnSize());
-
- assertEquals("Expected number of cols, double[][] parameter.", 1,
- new DenseLocalOffHeapMatrix(new double[][] {new double[1], new double[1]}).columnSize());
-
- double[][] data1 = new double[][] {{1, 2}, {3, 4}}, data2 = new double[][] {{1, 2}, {3, 5}};
-
- assertTrue("Matrices with same values are expected to be equal",
- new DenseLocalOffHeapMatrix(data1).equals(new DenseLocalOffHeapMatrix(data1)));
-
- assertFalse("Matrices with same values are expected to be equal",
- new DenseLocalOffHeapMatrix(data1).equals(new DenseLocalOffHeapMatrix(data2)));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java
deleted file mode 100644
index 0a25e31..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrixConstructorTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * 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.matrix;
-
-import java.util.function.Supplier;
-import org.apache.ignite.math.Matrix;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
-
-/** */
-public class DenseLocalOnHeapMatrixConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- verifyAssertionError(() -> new DenseLocalOnHeapMatrix(0, 1), "invalid row parameter");
-
- verifyAssertionError(() -> new DenseLocalOnHeapMatrix(1, 0), "invalid col parameter");
-
- //noinspection ConstantConditions
- verifyAssertionError(() -> new DenseLocalOnHeapMatrix(null), "null matrix parameter");
-
- verifyAssertionError(() -> new DenseLocalOnHeapMatrix(new double[][] {null, new double[1]}),
- "null row in matrix");
- }
-
- /** */
- @Test
- public void basicTest() {
- assertEquals("Expected number of rows, int parameters.", 1,
- new DenseLocalOnHeapMatrix(1, 2).rowSize());
-
- assertEquals("Expected number of rows, double[][] parameter.", 1,
- new DenseLocalOnHeapMatrix(new double[][] {new double[2]}).rowSize());
-
- assertEquals("Expected number of cols, int parameters.", 1,
- new DenseLocalOnHeapMatrix(2, 1).columnSize());
-
- assertEquals("Expected number of cols, double[][] parameter.", 1,
- new DenseLocalOnHeapMatrix(new double[][] {new double[1], new double[1]}).columnSize());
- }
-
- /** */
- static void verifyAssertionError(Supplier<Matrix> ctor, String desc) {
- try {
- assertNotNull("Unexpected null matrix in " + desc, ctor.get());
- }
- catch (AssertionError ae) {
- return;
- }
-
- fail("Expected error not caught in " + desc);
- }
-}
[07/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java
new file mode 100644
index 0000000..58f0fb4
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java
@@ -0,0 +1,152 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.nio.ByteBuffer;
+import java.util.Random;
+import org.apache.ignite.math.MurmurHash;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * {@link VectorStorage} implementation with random values in the vector elements.
+ */
+public class RandomVectorStorage implements VectorStorage {
+ /** */
+ private static final long SCALE = 1L << 32;
+ /** */
+ private static final int PRIME = 104047;
+
+ /** Random generation seed. */
+ private int seed;
+
+ /** Vector size. */
+ private int size;
+
+ /** Whether fast hash is used, in {@link #get(int)}. */
+ private boolean fastHash;
+
+ /** */
+ public RandomVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size Size of the storage.
+ * @param fastHash Whether or not to use fast hashing or Murmur hashing.
+ */
+ public RandomVectorStorage(int size, boolean fastHash) {
+ assert size > 0;
+
+ this.size = size;
+ this.fastHash = fastHash;
+
+ seed = new Random().nextInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ if (!fastHash) {
+ ByteBuffer buf = ByteBuffer.allocate(4);
+
+ buf.putInt(i);
+ buf.flip();
+
+ return (MurmurHash.hash64A(buf, seed) & (SCALE - 1)) / (double)SCALE;
+ }
+ else
+ // This isn't a fantastic random number generator, but it is just fine for random projections.
+ return (((i * PRIME) & 8) * 0.25) - 1;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ throw new UnsupportedOperationException("Random vector storage is a read-only storage.");
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(size);
+ out.writeInt(seed);
+ out.writeBoolean(fastHash);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ size = in.readInt();
+ seed = in.readInt();
+ fastHash = in.readBoolean();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + Boolean.hashCode(fastHash);
+ res = res * 37 + seed;
+ res = res * 37 + size;
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ RandomVectorStorage that = (RandomVectorStorage)o;
+
+ return size == that.size && seed == that.seed && fastHash == that.fastHash;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java
new file mode 100644
index 0000000..c5a4350
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java
@@ -0,0 +1,145 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * Single value view storage over another vector.
+ */
+public class SingleElementVectorDelegateStorage implements VectorStorage {
+ /** */ private int idx;
+ /** */ private Vector vec;
+
+ /**
+ *
+ */
+ public SingleElementVectorDelegateStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param vec Parent vector.
+ * @param idx Element index.
+ */
+ public SingleElementVectorDelegateStorage(Vector vec, int idx) {
+ assert vec != null;
+ assert idx >= 0;
+
+ this.vec = vec;
+ this.idx = idx;
+ }
+
+ /**
+ *
+ *
+ */
+ public int index() {
+ return idx;
+ }
+
+ /**
+ *
+ *
+ */
+ public Vector delegate() {
+ return vec;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return vec.size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return i == idx ? vec.get(i) : 0.0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ if (i == idx)
+ vec.set(i, v);
+ else
+ throw new UnsupportedOperationException("Can't set element outside of index: " + idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(vec);
+ out.writeInt(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ vec = (Vector)in.readObject();
+ idx = in.readInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ SingleElementVectorDelegateStorage that = (SingleElementVectorDelegateStorage)o;
+
+ return idx == that.idx && (vec != null ? vec.equals(that.vec) : that.vec == null);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = idx;
+
+ res = 31 * res + (vec != null ? vec.hashCode() : 0);
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java
new file mode 100644
index 0000000..3378817
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java
@@ -0,0 +1,143 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * Vector storage holding a single non-zero value at some index.
+ */
+public class SingleElementVectorStorage implements VectorStorage {
+ /** */ private int idx;
+ /** */ private double val;
+ /** */ private int size;
+
+ /**
+ *
+ */
+ public SingleElementVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size Parent vector size.
+ * @param idx Element index in the parent vector.
+ * @param val Value of the element.
+ */
+ public SingleElementVectorStorage(int size, int idx, double val) {
+ assert size > 0;
+ assert idx >= 0;
+
+ this.size = size;
+ this.idx = idx;
+ this.val = val;
+ }
+
+ /**
+ *
+ * @return Index of the element in the parent vector.
+ */
+ public int index() {
+ return idx;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return i == idx ? val : 0.0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ if (i == idx)
+ val = v;
+ else
+ throw new UnsupportedOperationException("Can't set element outside of index: " + idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(size);
+ out.writeInt(idx);
+ out.writeDouble(val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ size = in.readInt();
+ idx = in.readInt();
+ val = in.readDouble();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ SingleElementVectorStorage that = (SingleElementVectorStorage)o;
+
+ return idx == that.idx && Double.compare(that.val, val) == 0 && size == that.size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = idx;
+ long temp = Double.doubleToLongBits(val);
+
+ res = 31 * res + (int)(temp ^ (temp >>> 32));
+ res = 31 * res + size;
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java
new file mode 100644
index 0000000..9b912cb
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java
@@ -0,0 +1,148 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.nio.ByteBuffer;
+import org.apache.ignite.internal.util.offheap.GridOffHeapMap;
+import org.apache.ignite.internal.util.offheap.GridOffHeapMapFactory;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * {@link VectorStorage} implementation for {@link org.apache.ignite.math.impls.vector.SparseLocalOffHeapVector}.
+ */
+public class SparseLocalOffHeapVectorStorage implements VectorStorage {
+ /** Assume 10% density. */
+ private static final int INIT_DENSITY = 10;
+ /** Storage capacity. */
+ private int size;
+ /** Local off heap map. */
+ private GridOffHeapMap gridOffHeapMap;
+
+ /** */
+ public SparseLocalOffHeapVectorStorage() {
+ //No-op.
+ }
+
+ /** */
+ public SparseLocalOffHeapVectorStorage(int cap) {
+ assert cap > 0;
+
+ gridOffHeapMap = GridOffHeapMapFactory.unsafeMap(cap / INIT_DENSITY);
+ size = cap;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ byte[] bytes = gridOffHeapMap.get(hash(i), intToByteArray(i));
+ return bytes == null ? 0 : ByteBuffer.wrap(bytes).getDouble();
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ if (v != 0.0)
+ gridOffHeapMap.put(hash(i), intToByteArray(i), doubleToByteArray(v));
+ else if (gridOffHeapMap.contains(hash(i), intToByteArray(i)))
+ gridOffHeapMap.remove(hash(i), intToByteArray(i));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ throw new UnsupportedOperationException(); // TODO: add externalization support.
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void destroy() {
+ gridOffHeapMap.destruct();
+ }
+
+ /** */
+ private int hash(int h) {
+ // Apply base step of MurmurHash; see http://code.google.com/p/smhasher/
+ // Despite two multiplies, this is often faster than others
+ // with comparable bit-spread properties.
+ h ^= h >>> 16;
+ h *= 0x85ebca6b;
+ h ^= h >>> 13;
+ h *= 0xc2b2ae35;
+
+ return (h >>> 16) ^ h;
+ }
+
+ /** */
+ private byte[] intToByteArray(int val) {
+ return new byte[] {
+ (byte)(val >>> 24),
+ (byte)(val >>> 16),
+ (byte)(val >>> 8),
+ (byte)val};
+ }
+
+ /** */
+ private byte[] doubleToByteArray(double val) {
+ long l = Double.doubleToRawLongBits(val);
+ return new byte[] {
+ (byte)((l >> 56) & 0xff),
+ (byte)((l >> 48) & 0xff),
+ (byte)((l >> 40) & 0xff),
+ (byte)((l >> 32) & 0xff),
+ (byte)((l >> 24) & 0xff),
+ (byte)((l >> 16) & 0xff),
+ (byte)((l >> 8) & 0xff),
+ (byte)((l) & 0xff),
+ };
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java
new file mode 100644
index 0000000..b3a8a3c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java
@@ -0,0 +1,152 @@
+/*
+ * 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.storage.vector;
+
+import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
+import it.unimi.dsi.fastutil.ints.Int2DoubleRBTreeMap;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Map;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * Sparse, local, on-heap vector storage.
+ */
+public class SparseLocalOnHeapVectorStorage implements VectorStorage, StorageConstants {
+ /** */ private int size;
+ /** */ private int acsMode;
+
+ /** Actual map storage. */
+ private Map<Integer, Double> sto;
+
+ /**
+ *
+ */
+ public SparseLocalOnHeapVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size Vector size.
+ * @param acsMode Access mode.
+ */
+ public SparseLocalOnHeapVectorStorage(int size, int acsMode) {
+ assert size > 0;
+ assertAccessMode(acsMode);
+
+ this.size = size;
+ this.acsMode = acsMode;
+
+ if (acsMode == SEQUENTIAL_ACCESS_MODE)
+ sto = new Int2DoubleRBTreeMap();
+ else
+ sto = new Int2DoubleOpenHashMap();
+ }
+
+ /**
+ *
+ *
+ */
+ public int getAccessMode() {
+ return acsMode;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return sto.getOrDefault(i, 0.0);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ if (v != 0.0)
+ sto.put(i, v);
+ else if (sto.containsKey(i))
+ sto.remove(i);
+
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(size);
+ out.writeInt(acsMode);
+ out.writeObject(sto);
+ }
+
+ /** {@inheritDoc} */
+ @SuppressWarnings({"unchecked"})
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ size = in.readInt();
+ acsMode = in.readInt();
+ sto = (Map<Integer, Double>)in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return acsMode == SEQUENTIAL_ACCESS_MODE;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ SparseLocalOnHeapVectorStorage that = (SparseLocalOnHeapVectorStorage)o;
+
+ return size == that.size && acsMode == that.acsMode && (sto != null ? sto.equals(that.sto) : that.sto == null);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = size;
+
+ res = 31 * res + acsMode;
+ res = 31 * res + (sto != null ? sto.hashCode() : 0);
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java
new file mode 100644
index 0000000..a716e6a
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/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 specific implementations for vector storage models.
+ */
+package org.apache.ignite.math.impls.storage.vector;
\ 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/vector/AbstractReadOnlyVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java
new file mode 100644
index 0000000..58c583a
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java
@@ -0,0 +1,108 @@
+package org.apache.ignite.math.impls.vector;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.impls.matrix.FunctionMatrix;
+
+/**
+ * This class provides a helper implementation of the read-only implementation of {@link Vector}
+ * interface to minimize the effort required to implement it.
+ * Subclasses may override some of the implemented methods if a more
+ * specific or optimized implementation is desirable.
+ */
+public abstract class AbstractReadOnlyVector extends AbstractVector {
+ /** */
+ public AbstractReadOnlyVector() {
+ // No-op.
+ }
+
+ /**
+ * @param sto Storage.
+ */
+ public AbstractReadOnlyVector(VectorStorage sto) {
+ super(true, sto);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix cross(Vector vec) {
+ return new FunctionMatrix(size(), vec.size(),
+ (row, col) -> vec.get(col) * get(row));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix toMatrix(boolean rowLike) {
+ return new FunctionMatrix(rowLike ? 1 : size(), rowLike ? size() : 1,
+ (row, col) -> rowLike ? get(col) : get(row));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal) {
+ return new FunctionMatrix(rowLike ? 1 : size() + 1, rowLike ? size() + 1 : 1, (row, col) -> {
+ if (row == 0 && col == 0)
+ return zeroVal;
+
+ return rowLike ? get(col - 1) : get(row - 1);
+ });
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ return this; // This exploits read-only feature of this type vector.
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector logNormalize() {
+ return logNormalize(2.0, Math.sqrt(getLengthSquared()));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector logNormalize(double power) {
+ return logNormalize(power, kNorm(power));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteDoubleFunction<Double> fun) {
+ return new FunctionVector(size(), (i) -> fun.apply(get(i)));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun) {
+ checkCardinality(vec);
+
+ return new FunctionVector(size(), (i) -> fun.apply(get(i), vec.get(i)));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
+ return new FunctionVector(size(), (i) -> fun.apply(get(i), y));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector divide(double x) {
+ if (x == 1.0)
+ return this;
+
+ return new FunctionVector(size(), (i) -> get(i) / x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ return x == 0 ? new ConstantVector(size(), 0) : new FunctionVector(size(), (i) -> get(i) * x);
+ }
+
+ /**
+ * @param power Power.
+ * @param normLen Normalized length.
+ * @return logNormalized value.
+ */
+ private Vector logNormalize(double power, double normLen) {
+ assert !(Double.isInfinite(power) || power <= 1.0);
+
+ double denominator = normLen * Math.log(power);
+
+ return new FunctionVector(size(), (idx) -> Math.log1p(get(idx)) / denominator);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java
new file mode 100644
index 0000000..d84c0f3
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java
@@ -0,0 +1,903 @@
+/*
+ * 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.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.IntToDoubleFunction;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.impls.matrix.MatrixView;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * This class provides a helper implementation of the {@link Vector}
+ * interface to minimize the effort required to implement it.
+ * Subclasses may override some of the implemented methods if a more
+ * specific or optimized implementation is desirable.
+ */
+public abstract class AbstractVector implements Vector {
+ /** Vector storage implementation. */
+ private VectorStorage sto;
+
+ /** Meta attribute storage. */
+ private Map<String, Object> meta = new HashMap<>();
+
+ /** Vector's GUID. */
+ private IgniteUuid guid = IgniteUuid.randomUuid();
+
+ /** Cached value for length squared. */
+ private double lenSq = 0.0;
+
+ /** Maximum cached element. */
+ private Element maxElm = null;
+ /** Minimum cached element. */
+ private Element minElm = null;
+
+ /** Readonly flag (false by default). */
+ private boolean readOnly = false;
+
+ /** Read-only error message. */
+ private static final String RO_MSG = "Vector is read-only.";
+
+ /**
+ *
+ */
+ private void ensureReadOnly() {
+ if (readOnly)
+ throw new UnsupportedOperationException(RO_MSG);
+ }
+
+ /**
+ * @param sto Storage.
+ */
+ public AbstractVector(VectorStorage sto) {
+ this(false, sto);
+ }
+
+ /**
+ * @param readOnly Is read only.
+ * @param sto Storage.
+ */
+ public AbstractVector(boolean readOnly, VectorStorage sto) {
+ assert sto != null;
+
+ this.readOnly = readOnly;
+ this.sto = sto;
+ }
+
+ /**
+ *
+ */
+ public AbstractVector() {
+ // No-op.
+ }
+
+ /**
+ * Set storage.
+ *
+ * @param sto Storage.
+ */
+ protected void setStorage(VectorStorage sto) {
+ this.sto = sto;
+ }
+
+ /**
+ * @param i Index.
+ * @param v Value.
+ */
+ protected void storageSet(int i, double v) {
+ ensureReadOnly();
+
+ sto.set(i, v);
+
+ // Reset cached values.
+ lenSq = 0.0;
+ maxElm = minElm = null;
+ }
+
+ /**
+ * @param i Index.
+ * @return Value.
+ */
+ protected double storageGet(int i) {
+ return sto.get(i);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return sto.size();
+ }
+
+ /**
+ * Check index bounds.
+ *
+ * @param idx Index to check.
+ */
+ protected void checkIndex(int idx) {
+ if (idx < 0 || idx >= sto.size())
+ throw new IndexException(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int idx) {
+ checkIndex(idx);
+
+ return storageGet(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getX(int idx) {
+ return storageGet(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return sto.isArrayBased();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector sort() {
+ if (isArrayBased())
+ Arrays.parallelSort(sto.data());
+ else
+ throw new UnsupportedOperationException();
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteDoubleFunction<Double> fun) {
+ if (sto.isArrayBased()) {
+ double[] data = sto.data();
+
+ Arrays.setAll(data, (idx) -> fun.apply(data[idx]));
+ }
+ else {
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ storageSet(i, fun.apply(storageGet(i)));
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun) {
+ checkCardinality(vec);
+
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ storageSet(i, fun.apply(storageGet(i), vec.get(i)));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ storageSet(i, fun.apply(storageGet(i), y));
+
+ return this;
+ }
+
+ /**
+ * @param idx Index.
+ * @return Value.
+ */
+ protected Element makeElement(int idx) {
+ checkIndex(idx);
+
+ return new Element() {
+ /** {@inheritDoc} */
+ @Override public double get() {
+ return storageGet(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int index() {
+ return idx;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(double val) {
+ storageSet(idx, val);
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element minElement() {
+ if (minElm == null) {
+ int minIdx = 0;
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ if (storageGet(i) < storageGet(minIdx))
+ minIdx = i;
+
+ minElm = makeElement(minIdx);
+ }
+
+ return minElm;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element maxElement() {
+ if (maxElm == null) {
+ int maxIdx = 0;
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ if (storageGet(i) > storageGet(maxIdx))
+ maxIdx = i;
+
+ maxElm = makeElement(maxIdx);
+ }
+
+ return maxElm;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double minValue() {
+ return minElement().get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxValue() {
+ return maxElement().get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector set(int idx, double val) {
+ checkIndex(idx);
+
+ storageSet(idx, val);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector setX(int idx, double val) {
+ storageSet(idx, val);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector increment(int idx, double val) {
+ checkIndex(idx);
+
+ storageSet(idx, storageGet(idx) + val);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector incrementX(int idx, double val) {
+ storageSet(idx, storageGet(idx) + val);
+
+ return this;
+ }
+
+ /**
+ * Tests if given value is considered a zero value.
+ *
+ * @param val Value to check.
+ */
+ protected boolean isZero(double val) {
+ return val == 0.0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ double sum = 0;
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ sum += storageGet(i);
+
+ return sum;
+ }
+
+ /** {@inheritDoc} */
+ @Override public IgniteUuid guid() {
+ return guid;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Iterable<Element> all() {
+ return new Iterable<Element>() {
+ private int idx = 0;
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Element> iterator() {
+ return new Iterator<Element>() {
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return size() > 0 && idx < size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element next() {
+ if (hasNext())
+ return getElement(idx++);
+
+ throw new NoSuchElementException();
+ }
+ };
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public int nonZeroElements() {
+ int cnt = 0;
+
+ for (Element ignored : nonZeroes())
+ cnt++;
+
+ return cnt;
+ }
+
+ /** {@inheritDoc} */
+ @Override public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun,
+ T zeroVal) {
+ T res = zeroVal;
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ res = foldFun.apply(res, mapFun.apply(storageGet(i)));
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public <T> T foldMap(Vector vec, IgniteBiFunction<T, Double, T> foldFun,
+ IgniteBiFunction<Double, Double, Double> combFun, T zeroVal) {
+ checkCardinality(vec);
+
+ T res = zeroVal;
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ res = foldFun.apply(res, combFun.apply(storageGet(i), vec.getX(i)));
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Iterable<Element> nonZeroes() {
+ return new Iterable<Element>() {
+ private int idx = 0;
+ private int idxNext = -1;
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Element> iterator() {
+ return new Iterator<Element>() {
+ @Override public boolean hasNext() {
+ findNext();
+
+ return !over();
+ }
+
+ @Override public Element next() {
+ if (hasNext()) {
+ idx = idxNext;
+
+ return getElement(idxNext);
+ }
+
+ throw new NoSuchElementException();
+ }
+
+ private void findNext() {
+ if (over())
+ return;
+
+ if (idxNextInitialized() && idx != idxNext)
+ return;
+
+ if (idxNextInitialized())
+ idx = idxNext + 1;
+
+ while (idx < size() && isZero(get(idx)))
+ idx++;
+
+ idxNext = idx++;
+ }
+
+ private boolean over() {
+ return idxNext >= size();
+ }
+
+ private boolean idxNextInitialized() {
+ return idxNext != -1;
+ }
+ };
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public Map<String, Object> getMetaStorage() {
+ return meta;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(double val) {
+ if (sto.isArrayBased()) {
+ ensureReadOnly();
+
+ Arrays.fill(sto.data(), val);
+ }
+ else {
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ storageSet(i, val);
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(double[] vals) {
+ checkCardinality(vals);
+
+ if (sto.isArrayBased()) {
+ ensureReadOnly();
+
+ System.arraycopy(vals, 0, sto.data(), 0, vals.length);
+
+ lenSq = 0.0;
+ }
+ else {
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ storageSet(i, vals[i]);
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(Vector vec) {
+ checkCardinality(vec);
+
+ for (Vector.Element x : vec.all())
+ storageSet(x.index(), x.get());
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(IntToDoubleFunction fun) {
+ assert fun != null;
+
+ if (sto.isArrayBased()) {
+ ensureReadOnly();
+
+ Arrays.setAll(sto.data(), fun);
+ }
+ else {
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ storageSet(i, fun.applyAsDouble(i));
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Spliterator<Double> allSpliterator() {
+ return new Spliterator<Double>() {
+ /** {@inheritDoc} */
+ @Override public boolean tryAdvance(Consumer<? super Double> act) {
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ act.accept(storageGet(i));
+
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Spliterator<Double> trySplit() {
+ return null; // No Splitting.
+ }
+
+ /** {@inheritDoc} */
+ @Override public long estimateSize() {
+ return size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int characteristics() {
+ return ORDERED | SIZED;
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public Spliterator<Double> nonZeroSpliterator() {
+ return new Spliterator<Double>() {
+ /** {@inheritDoc} */
+ @Override public boolean tryAdvance(Consumer<? super Double> act) {
+ int len = size();
+
+ for (int i = 0; i < len; i++) {
+ double val = storageGet(i);
+
+ if (!isZero(val))
+ act.accept(val);
+ }
+
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Spliterator<Double> trySplit() {
+ return null; // No Splitting.
+ }
+
+ /** {@inheritDoc} */
+ @Override public long estimateSize() {
+ return nonZeroElements();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int characteristics() {
+ return ORDERED | SIZED;
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public double dot(Vector vec) {
+ checkCardinality(vec);
+
+ double sum = 0.0;
+ int len = size();
+
+ for (int i = 0; i < len; i++)
+ sum += storageGet(i) * vec.getX(i);
+
+ return sum;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getLengthSquared() {
+ if (lenSq == 0.0)
+ lenSq = dotSelf();
+
+ return lenSq;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return sto.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return sto.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return sto.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return sto.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public VectorStorage getStorage() {
+ return sto;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewPart(int off, int len) {
+ return new VectorView(this, off, len);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix cross(Vector vec) {
+ Matrix res = likeMatrix(size(), vec.size());
+
+ if (res == null)
+ return null;
+
+ for (Element e : nonZeroes()) {
+ int row = e.index();
+
+ res.assignRow(row, vec.times(getX(row)));
+ }
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix toMatrix(boolean rowLike) {
+ Matrix res = likeMatrix(rowLike ? 1 : size(), rowLike ? size() : 1);
+
+ if (res == null)
+ return null;
+
+ if (rowLike)
+ res.assignRow(0, this);
+ else
+ res.assignColumn(0, this);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal) {
+ Matrix res = likeMatrix(rowLike ? 1 : size() + 1, rowLike ? size() + 1 : 1);
+
+ if (res == null)
+ return null;
+
+ res.set(0, 0, zeroVal);
+
+ if (rowLike)
+ new MatrixView(res, 0, 1, 1, size()).assignRow(0, this);
+ else
+ new MatrixView(res, 1, 0, size(), 1).assignColumn(0, this);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getDistanceSquared(Vector vec) {
+ checkCardinality(vec);
+
+ double thisLenSq = getLengthSquared();
+ double thatLenSq = vec.getLengthSquared();
+ double dot = dot(vec);
+ double distEst = thisLenSq + thatLenSq - 2 * dot;
+
+ if (distEst > 1.0e-3 * (thisLenSq + thatLenSq))
+ // The vectors are far enough from each other that the formula is accurate.
+ return Math.max(distEst, 0);
+ else
+ return foldMap(vec, Functions.PLUS, Functions.MINUS_SQUARED, 0d);
+ }
+
+ /** */
+ protected void checkCardinality(Vector vec) {
+ if (vec.size() != size())
+ throw new CardinalityException(size(), vec.size());
+ }
+
+ /** */
+ protected void checkCardinality(double[] vec) {
+ if (vec.length != size())
+ throw new CardinalityException(size(), vec.length);
+ }
+
+ /** */
+ protected void checkCardinality(int[] arr) {
+ if (arr.length != size())
+ throw new CardinalityException(size(), arr.length);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector minus(Vector vec) {
+ checkCardinality(vec);
+
+ Vector cp = copy();
+
+ return cp.map(vec, Functions.MINUS);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector plus(double x) {
+ Vector cp = copy();
+
+ return x != 0.0 ? cp.map(Functions.plus(x)) : cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector divide(double x) {
+ Vector cp = copy();
+
+ if (x != 1.0)
+ for (Element element : cp.all())
+ element.set(element.get() / x);
+
+ return cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ if (x == 0.0)
+ return like(size());
+ else
+ return copy().map(Functions.mult(x));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(Vector vec) {
+ checkCardinality(vec);
+
+ return copy().map(vec, Functions.MULT);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector plus(Vector vec) {
+ checkCardinality(vec);
+
+ Vector cp = copy();
+
+ return cp.map(vec, Functions.PLUS);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector logNormalize() {
+ return logNormalize(2.0, Math.sqrt(getLengthSquared()));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector logNormalize(double power) {
+ return logNormalize(power, kNorm(power));
+ }
+
+ /**
+ * @param power Power.
+ * @param normLen Normalized length.
+ * @return logNormalized value.
+ */
+ private Vector logNormalize(double power, double normLen) {
+ assert !(Double.isInfinite(power) || power <= 1.0);
+
+ double denominator = normLen * Math.log(power);
+
+ Vector cp = copy();
+
+ for (Element element : cp.all())
+ element.set(Math.log1p(element.get()) / denominator);
+
+ return cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double kNorm(double power) {
+ assert power >= 0.0;
+
+ // Special cases.
+ if (Double.isInfinite(power))
+ return foldMap(Math::max, Math::abs, 0d);
+ else if (power == 2.0)
+ return Math.sqrt(getLengthSquared());
+ else if (power == 1.0)
+ return foldMap(Functions.PLUS, Math::abs, 0d);
+ else if (power == 0.0)
+ return nonZeroElements();
+ else
+ // Default case.
+ return Math.pow(foldMap(Functions.PLUS, Functions.pow(power), 0d), 1.0 / power);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector normalize() {
+ return divide(Math.sqrt(getLengthSquared()));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector normalize(double power) {
+ return divide(kNorm(power));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ return like(size()).assign(this);
+ }
+
+ /**
+ * @return Result of dot with self.
+ */
+ protected double dotSelf() {
+ double sum = 0.0;
+ int len = size();
+
+ for (int i = 0; i < len; i++) {
+ double v = storageGet(i);
+
+ sum += v * v;
+ }
+
+ return sum;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element getElement(int idx) {
+ return makeElement(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(sto);
+ out.writeObject(meta);
+ out.writeObject(guid);
+ out.writeBoolean(readOnly);
+ }
+
+ /** {@inheritDoc} */
+ @SuppressWarnings("unchecked")
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ sto = (VectorStorage)in.readObject();
+ meta = (Map<String, Object>)in.readObject();
+ guid = (IgniteUuid)in.readObject();
+ readOnly = in.readBoolean();
+ }
+
+ /** {@inheritDoc} */
+ @Override public void destroy() {
+ sto.destroy();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+ res += res * 37 + guid.hashCode();
+ res += sto == null ? 0 : res * 37 + sto.hashCode();
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ AbstractVector that = (AbstractVector)obj;
+
+ return (sto != null ? sto.equals(that.sto) : that.sto == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java
new file mode 100644
index 0000000..0e9b26f
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java
@@ -0,0 +1,140 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.ValueMapper;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorKeyMapper;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.impls.CacheUtils;
+import org.apache.ignite.math.impls.storage.vector.CacheVectorStorage;
+
+/**
+ * Vector based on existing cache and index and value mapping functions.
+ */
+public class CacheVector<K, V> extends AbstractVector {
+ /**
+ *
+ */
+ public CacheVector() {
+ // No-op.
+ }
+
+ /**
+ * Creates new vector over existing cache.
+ *
+ * @param size
+ * @param cache
+ * @param keyFunc
+ * @param valMapper
+ */
+ public CacheVector(
+ int size,
+ IgniteCache<K, V> cache,
+ VectorKeyMapper<K> keyFunc,
+ ValueMapper<V> valMapper) {
+ setStorage(new CacheVectorStorage<>(size, cache, keyFunc, valMapper));
+ }
+
+ /**
+ * @param mapper
+ */
+ private Vector mapOverCache(IgniteFunction<Double, Double> mapper) {
+ CacheVectorStorage<K, V> sto = storage();
+
+ CacheUtils.map(sto.cache().getName(), sto.keyMapper(), sto.valueMapper(), mapper);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double minValue() {
+ CacheVectorStorage<K, V> sto = storage();
+
+ return CacheUtils.min(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxValue() {
+ CacheVectorStorage<K, V> sto = storage();
+
+ return CacheUtils.max(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteDoubleFunction<Double> fun) {
+ return mapOverCache(fun::apply);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
+ // TODO: provide cache-optimized implementation.
+ return super.map(fun, y); // TODO
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ CacheVectorStorage<K, V> sto = storage();
+
+ return CacheUtils.sum(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(double val) {
+ return mapOverCache((Double d) -> val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector plus(double x) {
+ return mapOverCache((Double d) -> d + x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector divide(double x) {
+ return mapOverCache((Double d) -> d / x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ return mapOverCache((Double d) -> d * x);
+ }
+
+ /**
+ *
+ *
+ */
+ @SuppressWarnings({"unchecked"})
+ private CacheVectorStorage<K, V> storage() {
+ return (CacheVectorStorage<K, V>)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java
new file mode 100644
index 0000000..0fddfd6
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java
@@ -0,0 +1,84 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.storage.vector.ConstantVectorStorage;
+
+/**
+ * Constant value, read-only vector.
+ */
+public class ConstantVector extends AbstractReadOnlyVector {
+ /**
+ *
+ */
+ public ConstantVector() {
+ // No-op.
+ }
+
+ /**
+ * @param size
+ * @param val
+ */
+ public ConstantVector(int size, double val) {
+ super(new ConstantVectorStorage(size, val));
+ }
+
+ /**
+ *
+ *
+ */
+ private ConstantVectorStorage storage() {
+ return (ConstantVectorStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ ConstantVectorStorage sto = storage();
+
+ return new ConstantVector(sto.size(), sto.constant());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ return new ConstantVector(crd, storage().constant());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ ConstantVector that = (ConstantVector)o;
+
+ VectorStorage sto = getStorage();
+
+ return (sto != null ? sto.equals(that.getStorage()) : that.getStorage() == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java
new file mode 100644
index 0000000..a10fa45
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java
@@ -0,0 +1,391 @@
+/*
+ * 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.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Spliterator;
+import java.util.function.IntToDoubleFunction;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+
+/**
+ * Convenient class that can be used to add decorations to an existing vector. Subclasses
+ * can add weights, indices, etc. while maintaining full vector functionality.
+ */
+public class DelegatingVector implements Vector {
+ /** Delegating vector. */
+ private Vector dlg;
+
+ /** Meta attribute storage. */
+ private Map<String, Object> meta = new HashMap<>();
+
+ /** GUID. */
+ private IgniteUuid guid = IgniteUuid.randomUuid();
+
+ /** */
+ public DelegatingVector() {
+ // No-op.
+ }
+
+ /**
+ * @param dlg
+ */
+ public DelegatingVector(Vector dlg) {
+ assert dlg != null;
+
+ this.dlg = dlg;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(dlg);
+ out.writeObject(meta);
+ out.writeObject(guid);
+ }
+
+ /** {@inheritDoc} */
+ @SuppressWarnings("unchecked")
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ dlg = (Vector)in.readObject();
+ meta = (Map<String, Object>)in.readObject();
+ guid = (IgniteUuid)in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Map<String, Object> getMetaStorage() {
+ return meta;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return dlg.likeMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix toMatrix(boolean rowLike) {
+ return dlg.toMatrix(rowLike);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal) {
+ return dlg.toMatrixPlusOne(rowLike, zeroVal);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return dlg.size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return dlg.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double minValue() {
+ return dlg.minValue();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxValue() {
+ return dlg.maxValue();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return dlg.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return dlg.isArrayBased();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ return new DelegatingVector(dlg);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Iterable<Element> all() {
+ return dlg.all();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Iterable<Element> nonZeroes() {
+ return dlg.nonZeroes();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector sort() {
+ return dlg.sort();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Spliterator<Double> allSpliterator() {
+ return dlg.allSpliterator();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Spliterator<Double> nonZeroSpliterator() {
+ return dlg.nonZeroSpliterator();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element getElement(int idx) {
+ return dlg.getElement(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(double val) {
+ return dlg.assign(val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(double[] vals) {
+ return dlg.assign(vals);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(Vector vec) {
+ return dlg.assign(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(IntToDoubleFunction fun) {
+ return dlg.assign(fun);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteDoubleFunction<Double> fun) {
+ return dlg.map(fun);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun) {
+ return dlg.map(vec, fun);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
+ return dlg.map(fun, y);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector divide(double x) {
+ return dlg.divide(x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double dot(Vector vec) {
+ return dlg.dot(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int idx) {
+ return dlg.get(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getX(int idx) {
+ return dlg.getX(idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ return dlg.like(crd);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector minus(Vector vec) {
+ return dlg.minus(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector normalize() {
+ return dlg.normalize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector normalize(double power) {
+ return dlg.normalize(power);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector logNormalize() {
+ return dlg.logNormalize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector logNormalize(double power) {
+ return dlg.logNormalize(power);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double kNorm(double power) {
+ return dlg.kNorm(power);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element minElement() {
+ return dlg.minElement();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element maxElement() {
+ return dlg.maxElement();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector plus(double x) {
+ return dlg.plus(x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector plus(Vector vec) {
+ return dlg.plus(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector set(int idx, double val) {
+ return dlg.set(idx, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector setX(int idx, double val) {
+ return dlg.setX(idx, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector incrementX(int idx, double val) {
+ return dlg.incrementX(idx, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector increment(int idx, double val) {
+ return dlg.increment(idx, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int nonZeroElements() {
+ return dlg.nonZeroElements();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ return dlg.times(x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(Vector vec) {
+ return dlg.times(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewPart(int off, int len) {
+ return dlg.viewPart(off, len);
+ }
+
+ /** {@inheritDoc} */
+ @Override public VectorStorage getStorage() {
+ return dlg.getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ return dlg.sum();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix cross(Vector vec) {
+ return dlg.cross(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun,
+ T zeroVal) {
+ return dlg.foldMap(foldFun, mapFun, zeroVal);
+ }
+
+ /** {@inheritDoc} */
+ @Override public <T> T foldMap(Vector vec, IgniteBiFunction<T, Double, T> foldFun,
+ IgniteBiFunction<Double, Double, Double> combFun, T zeroVal) {
+ return dlg.foldMap(vec, foldFun, combFun, zeroVal);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getLengthSquared() {
+ return dlg.getLengthSquared();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getDistanceSquared(Vector vec) {
+ return dlg.getDistanceSquared(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return dlg.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return dlg.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public IgniteUuid guid() {
+ return guid;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void destroy() {
+ dlg.destroy();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + meta.hashCode();
+ res = res * 37 + dlg.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ DelegatingVector that = (DelegatingVector)o;
+
+ return meta.equals(that.meta) && dlg.equals(that.dlg);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java
new file mode 100644
index 0000000..4e7eb21
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java
@@ -0,0 +1,89 @@
+/*
+ * 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.vector;
+
+import java.util.stream.IntStream;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
+import org.apache.ignite.math.impls.storage.vector.DenseLocalOffHeapVectorStorage;
+
+/**
+ * Implementation for {@link Vector} assuming dense logic and local offheap JVM storage.
+ * It is suitable for data sets where local, non-distributed execution is satisfactory and on-heap JVM storage
+ * is not enough to keep the entire data set.
+ */
+public class DenseLocalOffHeapVector extends AbstractVector {
+ /** */
+ public DenseLocalOffHeapVector() {
+ // No-op.
+ }
+
+ /** */
+ private void makeOffheapStorage(int size) {
+ setStorage(new DenseLocalOffHeapVectorStorage(size));
+ }
+
+ /**
+ * @param arr Array to copy to offheap storage.
+ */
+ public DenseLocalOffHeapVector(double[] arr) {
+ makeOffheapStorage(arr.length);
+
+ assign(arr);
+ }
+
+ /**
+ * @param size Vector cardinality.
+ */
+ public DenseLocalOffHeapVector(int size) {
+ makeOffheapStorage(size);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector assign(Vector vec) {
+ checkCardinality(vec);
+
+ IntStream.range(0, size()).parallel().forEach(idx -> set(idx, vec.get(idx)));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ if (x == 0.0)
+ return like(size()).assign(0);
+ else
+ return super.times(x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ return new DenseLocalOffHeapVector(crd);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return new DenseLocalOffHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ return o != null && getClass().equals(o.getClass()) && (getStorage().equals(((Vector)o).getStorage()));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java
new file mode 100644
index 0000000..5827998
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java
@@ -0,0 +1,104 @@
+/*
+ * 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.vector;
+
+import java.util.Map;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.storage.vector.ArrayVectorStorage;
+
+/**
+ * Basic implementation for vector.
+ * <p>
+ * This is a trivial implementation for vector assuming dense logic, local on-heap JVM storage
+ * based on {@code double[]} array. It is only suitable for data sets where
+ * local, non-distributed execution is satisfactory and on-heap JVM storage is enough
+ * to keep the entire data set.
+ */
+public class DenseLocalOnHeapVector extends AbstractVector {
+ /**
+ * @param size Vector cardinality.
+ */
+ private VectorStorage mkStorage(int size) {
+ return new ArrayVectorStorage(size);
+ }
+
+ /**
+ * @param arr Source array.
+ * @param cp {@code true} to clone array, reuse it otherwise.
+ */
+ private VectorStorage mkStorage(double[] arr, boolean cp) {
+ assert arr != null;
+
+ return new ArrayVectorStorage(cp ? arr.clone() : arr);
+ }
+
+ /**
+ * @param args Parameters for new Vector.
+ */
+ public DenseLocalOnHeapVector(Map<String, Object> args) {
+ assert args != null;
+
+ if (args.containsKey("size"))
+ setStorage(mkStorage((int)args.get("size")));
+ else if (args.containsKey("arr") && args.containsKey("copy"))
+ setStorage(mkStorage((double[])args.get("arr"), (boolean)args.get("copy")));
+ else
+ throw new UnsupportedOperationException("Invalid constructor argument(s).");
+ }
+
+ /** */
+ public DenseLocalOnHeapVector() {
+ // No-op.
+ }
+
+ /**
+ * @param size Vector cardinality.
+ */
+ public DenseLocalOnHeapVector(int size) {
+ setStorage(mkStorage(size));
+ }
+
+ /**
+ * @param arr Source array.
+ * @param shallowCp {@code true} to use shallow copy.
+ */
+ public DenseLocalOnHeapVector(double[] arr, boolean shallowCp) {
+ setStorage(mkStorage(arr, shallowCp));
+ }
+
+ /**
+ * @param arr Source array.
+ */
+ public DenseLocalOnHeapVector(double[] arr) {
+ this(arr, false);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return new DenseLocalOnHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ return new DenseLocalOnHeapVector(crd);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java
new file mode 100644
index 0000000..0e7cfad
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java
@@ -0,0 +1,112 @@
+/*
+ * 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.vector;
+
+import java.util.Map;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.functions.IntDoubleToVoidFunction;
+import org.apache.ignite.math.impls.storage.vector.FunctionVectorStorage;
+
+/**
+ * Implementation of {@link Vector} that maps vector element index to {@link java.util.function} interfaces.
+ */
+public class FunctionVector extends AbstractVector {
+ /**
+ *
+ */
+ public FunctionVector() {
+ // No-op.
+ }
+
+ /**
+ * Creates read-write or read-only function vector.
+ *
+ * @param size Vector size.
+ * @param getFunc Function that returns value corresponding to given element index.
+ * @param setFunc Set function. If {@code null} - this will be a read-only vector.
+ */
+ public FunctionVector(int size, IgniteFunction<Integer, Double> getFunc, IntDoubleToVoidFunction setFunc) {
+ setStorage(new FunctionVectorStorage(size, getFunc, setFunc));
+ }
+
+ /**
+ * Creates read-only function vector.
+ *
+ * @param size Vector size.
+ * @param getFunc Function that returns value corresponding to given element index.
+ */
+ public FunctionVector(int size, IgniteFunction<Integer, Double> getFunc) {
+ setStorage(new FunctionVectorStorage(size, getFunc));
+ }
+
+ /**
+ * @param args Arguments for vector constructor.
+ */
+ public FunctionVector(Map<String, Object> args) {
+ assert args != null;
+
+ if (args.containsKey("size") && args.containsKey("getFunc") && args.containsKey("setFunc")) {
+ @SuppressWarnings("unchecked")
+ IgniteFunction<Integer, Double> getFunc = (IgniteFunction<Integer, Double>)args.get("getFunc");
+ IntDoubleToVoidFunction setFunc = (IntDoubleToVoidFunction)args.get("setFunc");
+ int size = (int)args.get("size");
+
+ setStorage(new FunctionVectorStorage(size, getFunc, setFunc));
+ }
+ else if (args.containsKey("size") && args.containsKey("getFunc")) {
+ @SuppressWarnings("unchecked")
+ IgniteFunction<Integer, Double> getFunc = (IgniteFunction<Integer, Double>)args.get("getFunc");
+ int size = (int)args.get("size");
+
+ setStorage(new FunctionVectorStorage(size, getFunc));
+ }
+ else
+ throw new UnsupportedOperationException("Invalid constructor argument(s).");
+ }
+
+ /**
+ *
+ *
+ */
+ private FunctionVectorStorage storage() {
+ return (FunctionVectorStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public org.apache.ignite.math.Vector like(int crd) {
+ FunctionVectorStorage sto = storage();
+
+ return new FunctionVector(crd, sto.getFunction(), sto.setFunction());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ if (x == 0.0)
+ return like(size()).assign(0);
+ else
+ return super.times(x);
+ }
+}
[12/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/README.txt
----------------------------------------------------------------------
diff --git a/modules/ml/README.txt b/modules/ml/README.txt
new file mode 100644
index 0000000..e0cc093
--- /dev/null
+++ b/modules/ml/README.txt
@@ -0,0 +1,15 @@
+Apache Ignite Math Module
+------------------------------
+
+Apache Ignite Math module provides several implementations of vector and matrices.
+
+Module includes on heap and off heap, dense and sparse, local and distributed implementations.
+
+Based on ideas from Apache Mahout.
+
+# Local build with javadoc
+
+Run from project root:
+mvn clean package -Pml -DskipTests -pl modules/ml -am
+
+Find generated jars in target folder.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/licenses/apache-2.0.txt
----------------------------------------------------------------------
diff --git a/modules/ml/licenses/apache-2.0.txt b/modules/ml/licenses/apache-2.0.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/modules/ml/licenses/apache-2.0.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed 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.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/licenses/mit.txt
----------------------------------------------------------------------
diff --git a/modules/ml/licenses/mit.txt b/modules/ml/licenses/mit.txt
new file mode 100644
index 0000000..00217dc
--- /dev/null
+++ b/modules/ml/licenses/mit.txt
@@ -0,0 +1,7 @@
+Copyright <YEAR> <COPYRIGHT HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/pom.xml
----------------------------------------------------------------------
diff --git a/modules/ml/pom.xml b/modules/ml/pom.xml
new file mode 100644
index 0000000..4755a2c
--- /dev/null
+++ b/modules/ml/pom.xml
@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+ 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.
+-->
+<!--
+ POM file.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <artifactId>ignite-parent</artifactId>
+ <groupId>org.apache.ignite</groupId>
+ <version>1</version>
+ <relativePath>../../parent</relativePath>
+ </parent>
+
+ <artifactId>ignite-ml</artifactId>
+ <version>2.0.0-SNAPSHOT</version>
+ <url>http://ignite.apache.org</url>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.ignite</groupId>
+ <artifactId>ignite-core</artifactId>
+ <version>${project.version}</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>it.unimi.dsi</groupId>
+ <artifactId>fastutil</artifactId>
+ <version>7.0.12</version>
+ </dependency>
+
+ <dependency>
+ <!-- IMPL NOTE this is to write math benchmarks results, IGN-6530 -->
+ <groupId>com.dropbox.core</groupId>
+ <artifactId>dropbox-core-sdk</artifactId>
+ <version>2.1.1</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>log4j</groupId>
+ <artifactId>log4j</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-beans</artifactId>
+ <version>${spring.version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-context</artifactId>
+ <version>${spring.version}</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+ <profiles>
+ <profile>
+ <id>math</id>
+ </profile>
+ </profiles>
+</project>
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/Algebra.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/Algebra.java b/modules/ml/src/main/java/org/apache/ignite/math/Algebra.java
new file mode 100644
index 0000000..6bfd608
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/Algebra.java
@@ -0,0 +1,571 @@
+/*
+ * 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.
+ */
+
+/*
+Copyright 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+
+package org.apache.ignite.math;
+
+/**
+ * Miscellaneous arithmetic and algebra functions.
+ * Lifted from Apache Mahout.
+ */
+public class Algebra extends Constants {
+ /** */ private static final double[] STIRLING_CORRECTION = {
+ 0.0,
+ 8.106146679532726e-02, 4.134069595540929e-02,
+ 2.767792568499834e-02, 2.079067210376509e-02,
+ 1.664469118982119e-02, 1.387612882307075e-02,
+ 1.189670994589177e-02, 1.041126526197209e-02,
+ 9.255462182712733e-03, 8.330563433362871e-03,
+ 7.573675487951841e-03, 6.942840107209530e-03,
+ 6.408994188004207e-03, 5.951370112758848e-03,
+ 5.554733551962801e-03, 5.207655919609640e-03,
+ 4.901395948434738e-03, 4.629153749334029e-03,
+ 4.385560249232324e-03, 4.166319691996922e-03,
+ 3.967954218640860e-03, 3.787618068444430e-03,
+ 3.622960224683090e-03, 3.472021382978770e-03,
+ 3.333155636728090e-03, 3.204970228055040e-03,
+ 3.086278682608780e-03, 2.976063983550410e-03,
+ 2.873449362352470e-03, 2.777674929752690e-03,
+ };
+
+ /** */ private static final double[] LOG_FACTORIALS = {
+ 0.00000000000000000, 0.00000000000000000, 0.69314718055994531,
+ 1.79175946922805500, 3.17805383034794562, 4.78749174278204599,
+ 6.57925121201010100, 8.52516136106541430, 10.60460290274525023,
+ 12.80182748008146961, 15.10441257307551530, 17.50230784587388584,
+ 19.98721449566188615, 22.55216385312342289, 25.19122118273868150,
+ 27.89927138384089157, 30.67186010608067280, 33.50507345013688888,
+ 36.39544520803305358, 39.33988418719949404, 42.33561646075348503,
+ 45.38013889847690803, 48.47118135183522388, 51.60667556776437357,
+ 54.78472939811231919, 58.00360522298051994, 61.26170176100200198,
+ 64.55753862700633106, 67.88974313718153498, 71.25703896716800901
+ };
+
+ /** */ private static final long[] LONG_FACTORIALS = {
+ 1L,
+ 1L,
+ 2L,
+ 6L,
+ 24L,
+ 120L,
+ 720L,
+ 5040L,
+ 40320L,
+ 362880L,
+ 3628800L,
+ 39916800L,
+ 479001600L,
+ 6227020800L,
+ 87178291200L,
+ 1307674368000L,
+ 20922789888000L,
+ 355687428096000L,
+ 6402373705728000L,
+ 121645100408832000L,
+ 2432902008176640000L
+ };
+
+ /** */ private static final double[] DOUBLE_FACTORIALS = {
+ 5.109094217170944E19,
+ 1.1240007277776077E21,
+ 2.585201673888498E22,
+ 6.204484017332394E23,
+ 1.5511210043330984E25,
+ 4.032914611266057E26,
+ 1.0888869450418352E28,
+ 3.048883446117138E29,
+ 8.841761993739701E30,
+ 2.652528598121911E32,
+ 8.222838654177924E33,
+ 2.6313083693369355E35,
+ 8.68331761881189E36,
+ 2.952327990396041E38,
+ 1.0333147966386144E40,
+ 3.719933267899013E41,
+ 1.3763753091226346E43,
+ 5.23022617466601E44,
+ 2.0397882081197447E46,
+ 8.15915283247898E47,
+ 3.34525266131638E49,
+ 1.4050061177528801E51,
+ 6.041526306337384E52,
+ 2.6582715747884495E54,
+ 1.196222208654802E56,
+ 5.502622159812089E57,
+ 2.5862324151116827E59,
+ 1.2413915592536068E61,
+ 6.082818640342679E62,
+ 3.0414093201713376E64,
+ 1.5511187532873816E66,
+ 8.06581751709439E67,
+ 4.274883284060024E69,
+ 2.308436973392413E71,
+ 1.2696403353658264E73,
+ 7.109985878048632E74,
+ 4.052691950487723E76,
+ 2.350561331282879E78,
+ 1.386831185456898E80,
+ 8.32098711274139E81,
+ 5.075802138772246E83,
+ 3.146997326038794E85,
+ 1.9826083154044396E87,
+ 1.2688693218588414E89,
+ 8.247650592082472E90,
+ 5.443449390774432E92,
+ 3.6471110918188705E94,
+ 2.48003554243683E96,
+ 1.7112245242814127E98,
+ 1.1978571669969892E100,
+ 8.504785885678624E101,
+ 6.123445837688612E103,
+ 4.470115461512686E105,
+ 3.307885441519387E107,
+ 2.4809140811395404E109,
+ 1.8854947016660506E111,
+ 1.451830920282859E113,
+ 1.1324281178206295E115,
+ 8.94618213078298E116,
+ 7.15694570462638E118,
+ 5.797126020747369E120,
+ 4.7536433370128435E122,
+ 3.94552396972066E124,
+ 3.314240134565354E126,
+ 2.8171041143805494E128,
+ 2.4227095383672744E130,
+ 2.107757298379527E132,
+ 1.854826422573984E134,
+ 1.6507955160908465E136,
+ 1.4857159644817605E138,
+ 1.3520015276784033E140,
+ 1.2438414054641305E142,
+ 1.156772507081641E144,
+ 1.0873661566567426E146,
+ 1.0329978488239061E148,
+ 9.916779348709491E149,
+ 9.619275968248216E151,
+ 9.426890448883248E153,
+ 9.332621544394415E155,
+ 9.332621544394418E157,
+ 9.42594775983836E159,
+ 9.614466715035125E161,
+ 9.902900716486178E163,
+ 1.0299016745145631E166,
+ 1.0813967582402912E168,
+ 1.1462805637347086E170,
+ 1.2265202031961373E172,
+ 1.324641819451829E174,
+ 1.4438595832024942E176,
+ 1.5882455415227423E178,
+ 1.7629525510902457E180,
+ 1.974506857221075E182,
+ 2.2311927486598138E184,
+ 2.543559733472186E186,
+ 2.925093693493014E188,
+ 3.393108684451899E190,
+ 3.96993716080872E192,
+ 4.6845258497542896E194,
+ 5.574585761207606E196,
+ 6.689502913449135E198,
+ 8.094298525273444E200,
+ 9.875044200833601E202,
+ 1.2146304367025332E205,
+ 1.506141741511141E207,
+ 1.882677176888926E209,
+ 2.3721732428800483E211,
+ 3.0126600184576624E213,
+ 3.856204823625808E215,
+ 4.974504222477287E217,
+ 6.466855489220473E219,
+ 8.471580690878813E221,
+ 1.1182486511960037E224,
+ 1.4872707060906847E226,
+ 1.99294274616152E228,
+ 2.690472707318049E230,
+ 3.6590428819525483E232,
+ 5.0128887482749884E234,
+ 6.917786472619482E236,
+ 9.615723196941089E238,
+ 1.3462012475717523E241,
+ 1.8981437590761713E243,
+ 2.6953641378881633E245,
+ 3.8543707171800694E247,
+ 5.550293832739308E249,
+ 8.047926057471989E251,
+ 1.1749972043909107E254,
+ 1.72724589045464E256,
+ 2.5563239178728637E258,
+ 3.8089226376305687E260,
+ 5.7133839564458575E262,
+ 8.627209774233244E264,
+ 1.3113358856834527E267,
+ 2.0063439050956838E269,
+ 3.0897696138473515E271,
+ 4.789142901463393E273,
+ 7.471062926282892E275,
+ 1.1729568794264134E278,
+ 1.8532718694937346E280,
+ 2.946702272495036E282,
+ 4.714723635992061E284,
+ 7.590705053947223E286,
+ 1.2296942187394494E289,
+ 2.0044015765453032E291,
+ 3.287218585534299E293,
+ 5.423910666131583E295,
+ 9.003691705778434E297,
+ 1.5036165148649983E300,
+ 2.5260757449731988E302,
+ 4.2690680090047056E304,
+ 7.257415615308004E306
+ };
+
+ /**
+ * Efficiently returns the binomial coefficient, often also referred to as
+ * "n over k" or "n choose k". The binomial coefficient is defined as
+ * {@code (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )}.
+ * <ul> <li>{@code k<0}: {@code 0}.</li>
+ * <li>{@code k==0}: {@code 1}.</li>
+ * <li>{@code k==1}: {@code n}.</li>
+ * <li>else: {@code (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k)}.</li>
+ * </ul>
+ *
+ * @param n
+ * @param k
+ * @return Binomial coefficient.
+ */
+ public static double binomial(double n, long k) {
+ if (k < 0)
+ return 0;
+
+ if (k == 0)
+ return 1;
+
+ if (k == 1)
+ return n;
+
+ // binomial(n,k) = (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )
+ double a = n - k + 1;
+ double b = 1;
+ double binomial = 1;
+
+ for (long i = k; i-- > 0; )
+ binomial *= (a++) / (b++);
+
+ return binomial;
+ }
+
+ /**
+ * Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k".
+ * The binomial coefficient is defined as
+ * <ul> <li>{@code k<0}: {@code 0}. <li>{@code k==0 || k==n}: {@code 1}. <li>{@code k==1 || k==n-1}:
+ * {@code n}. <li>else: {@code (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )}. </ul>
+ *
+ * @param n
+ * @param k
+ * @return Binomial coefficient.
+ */
+ public static double binomial(long n, long k) {
+ if (k < 0)
+ return 0;
+
+ if (k == 0 || k == n)
+ return 1;
+
+ if (k == 1 || k == n - 1)
+ return n;
+
+ if (n > k) {
+ int max = LONG_FACTORIALS.length + DOUBLE_FACTORIALS.length;
+
+ if (n < max) {
+ double nFac = factorial((int)n);
+ double kFac = factorial((int)k);
+ double nMinusKFac = factorial((int)(n - k));
+ double nk = nMinusKFac * kFac;
+
+ if (nk != Double.POSITIVE_INFINITY) // No numeric overflow?
+ return nFac / nk;
+ }
+
+ if (k > n / 2)
+ k = n - k;
+ }
+
+ // binomial(n,k) = (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )
+ long a = n - k + 1;
+ long b = 1;
+ double binomial = 1;
+
+ for (long i = k; i-- > 0; )
+ binomial *= (double)a++ / (b++);
+
+ return binomial;
+ }
+
+ /**
+ * Returns the smallest <code>long >= value</code>.
+ * <dl><dt>Examples: {@code 1.0 -> 1, 1.2 -> 2, 1.9 -> 2}. This
+ * method is safer than using (long) Math.ceil(value), because of possible rounding error.</dt></dl>
+ *
+ * @param val
+ */
+ public static long ceil(double val) {
+ return Math.round(Math.ceil(val));
+ }
+
+ /**
+ * Evaluates the series of Chebyshev polynomials Ti at argument x/2. The series is given by
+ * <pre>
+ * N-1
+ * - '
+ * y = > coef[i] T (x/2)
+ * - i
+ * i=0
+ * </pre>
+ * Coefficients are stored in reverse order, i.e. the zero order term is last in the array. Note N is the number of
+ * coefficients, not the order. <p> If coefficients are for the interval a to b, x must have been transformed to x
+ * -< 2(2x - b - a)/(b-a) before entering the routine. This maps x from (a, b) to (-1, 1), over which the
+ * Chebyshev polynomials are defined. <p> If the coefficients are for the inverted interval, in which (a, b) is
+ * mapped to (1/b, 1/a), the transformation required is {@code x -> 2(2ab/x - b - a)/(b-a)}. If b is infinity, this
+ * becomes {@code x -> 4a/x - 1}. <p> SPEED: <p> Taking advantage of the recurrence properties of the Chebyshev
+ * polynomials, the routine requires one more addition per loop than evaluating a nested polynomial of the same
+ * degree.
+ *
+ * @param x Argument to the polynomial.
+ * @param coef Coefficients of the polynomial.
+ * @param N Number of coefficients.
+ */
+ public static double chbevl(double x, double[] coef, int N) {
+ int p = 0;
+
+ double b0 = coef[p++];
+ double b1 = 0.0;
+ int i = N - 1;
+
+ double b2;
+
+ do {
+ b2 = b1;
+ b1 = b0;
+ b0 = x * b1 - b2 + coef[p++];
+ }
+ while (--i > 0);
+
+ return 0.5 * (b0 - b2);
+ }
+
+ /**
+ * Instantly returns the factorial {@code k!}.
+ *
+ * @param k must hold {@code k >= 0}.
+ */
+ private static double factorial(int k) {
+ if (k < 0)
+ throw new IllegalArgumentException();
+
+ int len1 = LONG_FACTORIALS.length;
+
+ if (k < len1)
+ return LONG_FACTORIALS[k];
+
+ int len2 = DOUBLE_FACTORIALS.length;
+
+ return (k < len1 + len2) ? DOUBLE_FACTORIALS[k - len1] : Double.POSITIVE_INFINITY;
+ }
+
+ /**
+ * Returns the largest <code>long <= value</code>.
+ * <dl><dt>Examples: {@code 1.0 -> 1, 1.2 -> 1, 1.9 -> 1 <dt> 2.0 -> 2, 2.2 -> 2, 2.9 -> 2}</dt></dl>
+ * This method is safer than using (long) Math.floor(value), because of possible rounding error.
+ */
+ public static long floor(double val) {
+ return Math.round(Math.floor(val));
+ }
+
+ /**
+ * Returns {@code log<sub>base</sub>value}.
+ */
+ public static double log(double base, double val) {
+ return Math.log(val) / Math.log(base);
+ }
+
+ /**
+ * Returns {@code log<sub>10</sub>value}.
+ */
+ public static double log10(double val) {
+ // 1.0 / Math.log(10) == 0.43429448190325176
+ return Math.log(val) * 0.43429448190325176;
+ }
+
+ /**
+ * Returns {@code log<sub>2</sub>value}.
+ */
+ public static double log2(double val) {
+ // 1.0 / Math.log(2) == 1.4426950408889634
+ return Math.log(val) * 1.4426950408889634;
+ }
+
+ /**
+ * Returns {@code log(k!)}. Tries to avoid overflows. For {@code k<30} simply looks up a table in O(1).
+ * For {@code k>=30} uses stirlings approximation.
+ *
+ * @param k must hold {@code k >= 0}.
+ */
+ public static double logFactorial(int k) {
+ if (k >= 30) {
+ double r = 1.0 / k;
+ double rr = r * r;
+ double C7 = -5.95238095238095238e-04;
+ double C5 = 7.93650793650793651e-04;
+ double C3 = -2.77777777777777778e-03;
+ double C1 = 8.33333333333333333e-02;
+ double C0 = 9.18938533204672742e-01;
+
+ return (k + 0.5) * Math.log(k) - k + C0 + r * (C1 + rr * (C3 + rr * (C5 + rr * C7)));
+ }
+ else
+ return LOG_FACTORIALS[k];
+ }
+
+ /**
+ * Instantly returns the factorial {@code k!}.
+ *
+ * @param k must hold {@code k >= 0 && k < 21}
+ */
+ public static long longFactorial(int k) {
+ if (k < 0)
+ throw new IllegalArgumentException("Negative k");
+
+ if (k < LONG_FACTORIALS.length)
+ return LONG_FACTORIALS[k];
+
+ throw new IllegalArgumentException("Overflow");
+ }
+
+ /**
+ * Returns the StirlingCorrection.
+ *
+ * Correction term of the Stirling approximation for {@code log(k!)} (series in
+ * 1/k, or table values for small k) with int parameter k. </p> {@code log k! = (k + 1/2)log(k + 1) - (k + 1) +
+ * (1/2)log(2Pi) + STIRLING_CORRECTION(k + 1) log k! = (k + 1/2)log(k) - k + (1/2)log(2Pi) +
+ * STIRLING_CORRECTION(k) }
+ */
+ public static double stirlingCorrection(int k) {
+ if (k > 30) {
+ double r = 1.0 / k;
+ double rr = r * r;
+ double C7 = -5.95238095238095238e-04;
+ double C5 = 7.93650793650793651e-04;
+ double C3 = -2.77777777777777778e-03;
+ double C1 = 8.33333333333333333e-02;
+
+ return r * (C1 + rr * (C3 + rr * (C5 + rr * C7)));
+ }
+ else
+ return STIRLING_CORRECTION[k];
+ }
+
+ /**
+ * Evaluates the given polynomial of degree {@code N} at {@code x}, assuming coefficient of N is 1.0. Otherwise same
+ * as {@link #evalPoly(double, double[], int)}.
+ * <pre>
+ * 2 N
+ * y = C + C x + C x +...+ C x
+ * 0 1 2 N
+ *
+ * where C = 1 and hence is omitted from the array.
+ * N
+ *
+ * Coefficients are stored in reverse order:
+ *
+ * coef[0] = C , ..., coef[N-1] = C .
+ * N-1 0
+ *
+ * Calling arguments are otherwise the same as {@link #evalPoly(double, double[], int)}.
+ * </pre>
+ * In the interest of speed, there are no checks for out of bounds arithmetic.
+ *
+ * @param x Argument to the polynomial.
+ * @param coef Coefficients of the polynomial.
+ * @param n Degree of the polynomial.
+ */
+ public static double evalPoly1(double x, double[] coef, int n) {
+ double res = x + coef[0];
+
+ for (int i = 1; i < n; i++)
+ res = res * x + coef[i];
+
+ return res;
+ }
+
+ /**
+ * Evaluates the given polynomial of degree {@code N} at {@code x}.
+ * <pre>
+ * 2 N
+ * y = C + C x + C x +...+ C x
+ * 0 1 2 N
+ *
+ * Coefficients are stored in reverse order:
+ *
+ * coef[0] = C , ..., coef[N] = C .
+ * N 0
+ * </pre>
+ * In the interest of speed, there are no checks for out of bounds arithmetic.
+ *
+ * @param x Argument to the polynomial.
+ * @param coef Coefficients of the polynomial.
+ * @param n Degree of the polynomial.
+ */
+ public static double evalPoly(double x, double[] coef, int n) {
+ double res = coef[0];
+
+ for (int i = 1; i <= n; i++)
+ res = res * x + coef[i];
+
+ return res;
+ }
+
+ /**
+ * Gets <code>sqrt(a^2 + b^2)</code> without under/overflow.
+ *
+ * @param a
+ * @param b
+ */
+ public static double hypot(double a, double b) {
+ double r;
+
+ if (Math.abs(a) > Math.abs(b)) {
+ r = b / a;
+ r = Math.abs(a) * Math.sqrt(1 + r * r);
+ }
+ else if (b != 0) {
+ r = a / b;
+ r = Math.abs(b) * Math.sqrt(1 + r * r);
+ }
+ else
+ r = 0.0;
+
+ return r;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/Constants.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/Constants.java b/modules/ml/src/main/java/org/apache/ignite/math/Constants.java
new file mode 100644
index 0000000..02756b6
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/Constants.java
@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+
+/*
+Copyright 1999 CERN - European Organization for Nuclear Research.
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
+is hereby granted without fee, provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in supporting documentation.
+CERN makes no representations about the suitability of this software for any purpose.
+It is provided "as is" without expressed or implied warranty.
+*/
+
+package org.apache.ignite.math;
+
+/**
+ * Math constants. Lifted from Apache Mahout.
+ */
+public class Constants {
+ /** */ public static final double MACHEP = 1.11022302462515654042E-16;
+ /** */ public static final double MAXLOG = 7.09782712893383996732E2;
+ /** */ public static final double MINLOG = -7.451332191019412076235E2;
+ /** */ public static final double MAXGAM = 171.624376956302725;
+ /** */ public static final double SQTPI = 2.50662827463100050242E0;
+ /** */ public static final double SQRTH = 7.07106781186547524401E-1;
+ /** */ public static final double LOGPI = 1.14472988584940017414;
+ /** */ public static final double BIG = 4.503599627370496e15;
+ /** */ public static final double BIGINV = 2.22044604925031308085e-16;
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/Destroyable.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/Destroyable.java b/modules/ml/src/main/java/org/apache/ignite/math/Destroyable.java
new file mode 100644
index 0000000..f3b467c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/Destroyable.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;
+
+/**
+ * Support for destroying objects that are managed outside of JVM.
+ */
+public interface Destroyable {
+ /**
+ * Destroys object if managed outside of JVM. It's a no-op in all other cases.
+ */
+ public default void destroy() {
+ // No-op.
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/IdentityValueMapper.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/IdentityValueMapper.java b/modules/ml/src/main/java/org/apache/ignite/math/IdentityValueMapper.java
new file mode 100644
index 0000000..65c7024
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/IdentityValueMapper.java
@@ -0,0 +1,53 @@
+/*
+ * 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;
+
+/**
+ * Identity value mapper.
+ */
+public class IdentityValueMapper implements ValueMapper<Double> {
+ /** */ private static final long serialVersionUID = -8010078306142216389L;
+
+ /** {@inheritDoc} */
+ @Override public Double fromDouble(double v) {
+ return v;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double toDouble(Double v) {
+ assert v != null;
+
+ return v;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ return Long.hashCode(serialVersionUID);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ return true;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/KeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/KeyMapper.java b/modules/ml/src/main/java/org/apache/ignite/math/KeyMapper.java
new file mode 100644
index 0000000..f4f9a39
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/KeyMapper.java
@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import java.io.Serializable;
+
+/**
+ * Maps key objects to index in {@link Vector} or {@link Matrix}.
+ */
+public interface KeyMapper<K> extends Serializable {
+ /**
+ * Checks given cache key corresponds to a valid index in vector or matrix.
+ *
+ * @param k Key to check.
+ * @return {@code true} if there is a valid index, {@code false} otherwise.
+ */
+ public boolean isValid(K k);
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/Matrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/Matrix.java b/modules/ml/src/main/java/org/apache/ignite/math/Matrix.java
new file mode 100644
index 0000000..ee7a807
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/Matrix.java
@@ -0,0 +1,518 @@
+/*
+ * 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;
+
+import java.io.Externalizable;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.functions.IntIntToDoubleFunction;
+
+/**
+ * A matrix interface.
+ *
+ * Based on its flavor it can have vastly different implementations tailored for
+ * for different types of data (e.g. dense vs. sparse), different sizes of data or different operation
+ * optimizations.
+ *
+ * Note also that not all operations can be supported by all underlying implementations. If an operation is not
+ * supported a {@link UnsupportedOperationException} is thrown. This exception can also be thrown in partial cases
+ * where an operation is unsupported only in special cases, e.g. where a given operation cannot be deterministically
+ * completed in polynomial time.
+ *
+ * Based on ideas from <a href="http://mahout.apache.org/">Apache Mahout</a>.
+ */
+public interface Matrix extends MetaAttributes, Externalizable, StorageOpsMetrics, Destroyable {
+ /**
+ * Holder for matrix's element.
+ */
+ interface Element {
+ /**
+ * Gets element's value.
+ *
+ * @return The value of this matrix element.
+ */
+ double get();
+
+ /**
+ * Gets element's row index.
+ *
+ * @return The row index of this element.
+ */
+ int row();
+
+ /**
+ * Gets element's column index.
+ *
+ * @return The column index of this element.
+ */
+ int column();
+
+ /**
+ * Sets element's value.
+ *
+ * @param val Value to set.
+ */
+ void set(double val);
+ }
+
+ /**
+ * Gets the maximum value in this matrix.
+ *
+ * @return Maximum value in this matrix.
+ */
+ public double maxValue();
+
+ /**
+ * Gets the minimum value in this matrix.
+ *
+ * @return Minimum value in this matrix.
+ */
+ public double minValue();
+
+ /**
+ * Gets the maximum element in this matrix.
+ *
+ * @return Maximum element in this matrix.
+ */
+ public Element maxElement();
+
+ /**
+ * Gets the minimum element in this matrix.
+ *
+ * @return Minimum element in this matrix.
+ */
+ public Element minElement();
+
+ /**
+ * Gets the matrix's element at the given coordinates.
+ *
+ * @param row Row index.
+ * @param col Column index.
+ * @return Element at the given coordinates.
+ */
+ public Element getElement(int row, int col);
+
+ /**
+ * Swaps two rows in this matrix.
+ *
+ * @param row1 Row #1.
+ * @param row2 Row #2.
+ * @return This matrix.
+ */
+ public Matrix swapRows(int row1, int row2);
+
+ /**
+ * Swaps two columns in this matrix.
+ *
+ * @param col1 Column #1.
+ * @param col2 Column #2.
+ * @return This matrix.
+ */
+ public Matrix swapColumns(int col1, int col2);
+
+ /**
+ * Assigns given value to all elements of this matrix.
+ *
+ * @param val Value to assign to all elements.
+ * @return This matrix.
+ */
+ public Matrix assign(double val);
+
+ /**
+ * Assigns given values to this matrix.
+ *
+ * @param vals Values to assign.
+ * @return This matrix.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix assign(double[][] vals);
+
+ /**
+ * Assigns values from given matrix to this matrix.
+ *
+ * @param mtx Matrix to assign to this matrix.
+ * @return This matrix.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix assign(Matrix mtx);
+
+ /**
+ * Assigns each matrix element to the value generated by given function.
+ *
+ * @param fun Function that takes the row and column and returns the value to assign.
+ * @return This matrix.
+ */
+ public Matrix assign(IntIntToDoubleFunction fun);
+
+ /**
+ * Maps all values in this matrix through a given function.
+ *
+ * @param fun Mapping function.
+ * @return This matrix.
+ */
+ public Matrix map(IgniteDoubleFunction<Double> fun);
+
+ /**
+ * Maps all values in this matrix through a given function.
+ *
+ * For this matrix <code>A</code>, argument matrix <code>B</code> and the
+ * function <code>F</code> this method maps every cell <code>x, y</code> as:
+ * <code>A(x,y) = fun(A(x,y), B(x,y))</code>
+ *
+ * @param mtx Argument matrix.
+ * @param fun Mapping function.
+ * @return This function.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix map(Matrix mtx, IgniteBiFunction<Double, Double, Double> fun);
+
+ /**
+ * Assigns values from given vector to the specified column in this matrix.
+ *
+ * @param col Column index.
+ * @param vec Vector to get values from.
+ * @return This matrix.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix assignColumn(int col, Vector vec);
+
+ /**
+ * Assigns values from given vector to the specified row in this matrix.
+ *
+ * @param row Row index.
+ * @param vec Vector to get values from.
+ * @return This matrix.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix assignRow(int row, Vector vec);
+
+ /**
+ * Collects the results of applying a given function to all rows in this matrix.
+ *
+ * @param fun Aggregating function.
+ * @return Vector of row aggregates.
+ */
+ public Vector foldRows(IgniteFunction<Vector, Double> fun);
+
+ /**
+ * Collects the results of applying a given function to all columns in this matrix.
+ *
+ * @param fun Aggregating function.
+ * @return Vector of column aggregates.
+ */
+ public Vector foldColumns(IgniteFunction<Vector, Double> fun);
+
+ /**
+ * Folds this matrix into a single value.
+ *
+ * @param foldFun Folding function that takes two parameters: accumulator and the current value.
+ * @param mapFun Mapping function that is called on each matrix cell before its passed to the accumulator (as its
+ * second parameter).
+ * @param <T> Type of the folded value.
+ * @param zeroVal Zero value for fold function.
+ * @return Folded value of this matrix.
+ */
+ public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun, T zeroVal);
+
+ /**
+ * Calculates the density of the matrix based on supplied criteria.
+ * Returns {@code true} if this matrix is denser than threshold with at least 80% confidence.
+ *
+ * @param threshold the threshold value [0, 1] of non-zero elements above which the matrix is considered dense.
+ */
+ public boolean density(double threshold);
+
+ /**
+ * Gets number of columns in this matrix.
+ *
+ * @return The number of columns in this matrix.
+ */
+ public int columnSize();
+
+ /**
+ * Gets number of rows in this matrix.
+ *
+ * @return The number of rows in this matrix.
+ */
+ public int rowSize();
+
+ /**
+ * Returns matrix determinant using Laplace theorem.
+ *
+ * @return A determinant for this matrix.
+ * @throws CardinalityException Thrown if matrix is not square.
+ */
+ public double determinant();
+
+ /**
+ * Returns the inverse matrix of this matrix
+ *
+ * @return Inverse of this matrix
+ */
+ public Matrix inverse();
+
+ /**
+ * Divides each value in this matrix by the argument.
+ *
+ * @param x Divider value.
+ * @return This matrix.
+ */
+ public Matrix divide(double x);
+
+ /**
+ * Gets the matrix value at the provided location.
+ *
+ * @param row Row index.
+ * @param col Column index.
+ * @return Matrix value.
+ * @throws IndexException Thrown in case of index is out of bound.
+ */
+ public double get(int row, int col);
+
+ /**
+ * Gets the matrix value at the provided location without checking boundaries.
+ * This method is marginally quicker than its {@link #get(int, int)} sibling.
+ *
+ * @param row Row index.
+ * @param col Column index.
+ * @return Matrix value.
+ */
+ public double getX(int row, int col);
+
+ /**
+ * Gets matrix storage model.
+ */
+ public MatrixStorage getStorage();
+
+ /**
+ * Clones this matrix.
+ *
+ * NOTE: new matrix will have the same flavor as the this matrix but a different ID.
+ *
+ * @return New matrix of the same underlying class, the same size and the same values.
+ */
+ public Matrix copy();
+
+ /**
+ * Creates new empty matrix of the same underlying class but of different size.
+ *
+ * NOTE: new matrix will have the same flavor as the this matrix but a different ID.
+ *
+ * @param rows Number of rows for new matrix.
+ * @param cols Number of columns for new matrix.
+ * @return New matrix of the same underlying class and size.
+ */
+ public Matrix like(int rows, int cols);
+
+ /**
+ * Creates new empty vector of compatible properties (similar or the same flavor) to this matrix.
+ *
+ * @param crd Cardinality of the vector.
+ * @return Newly created empty vector "compatible" to this matrix.
+ */
+ public Vector likeVector(int crd);
+
+ /**
+ * Creates new matrix where each value is a difference between corresponding value of this matrix and
+ * passed in argument matrix.
+ *
+ * @param mtx Argument matrix.
+ * @return New matrix of the same underlying class and size.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix minus(Matrix mtx);
+
+ /**
+ * Creates new matrix where each value is a sum of the corresponding value of this matrix and
+ * argument value.
+ *
+ * @param x Value to add.
+ * @return New matrix of the same underlying class and size.
+ */
+ public Matrix plus(double x);
+
+ /**
+ * Creates new matrix where each value is a sum of corresponding values of this matrix and
+ * passed in argument matrix.
+ *
+ * @param mtx Argument matrix.
+ * @return New matrix of the same underlying class and size.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix plus(Matrix mtx);
+
+ /**
+ * Auto-generated globally unique matrix ID.
+ *
+ * @return Matrix GUID.
+ */
+ public IgniteUuid guid();
+
+ /**
+ * Sets given value.
+ *
+ * @param row Row index.
+ * @param col Column index.
+ * @param val Value to set.
+ * @return This matrix.
+ * @throws IndexException Thrown in case of either index is out of bound.
+ */
+ public Matrix set(int row, int col, double val);
+
+ /**
+ * Sets values for given row.
+ *
+ * @param row Row index.
+ * @param data Row data to set.
+ * @return This matrix.
+ * @throws IndexException Thrown in case of index is out of bound.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix setRow(int row, double[] data);
+
+ /**
+ * Sets values for given column.
+ *
+ * @param col Column index.
+ * @param data Column data to set.
+ * @return This matrix.
+ * @throws IndexException Thrown in case of index is out of bound.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix setColumn(int col, double[] data);
+
+ /**
+ * Sets given value without checking for index bounds. This method is marginally faster
+ * than its {@link #set(int, int, double)} sibling.
+ *
+ * @param row Row index.
+ * @param col Column index.
+ * @param val Value to set.
+ * @return This matrix.
+ */
+ public Matrix setX(int row, int col, double val);
+
+ /**
+ * Creates new matrix containing the product of given value and values in this matrix.
+ *
+ * @param x Value to multiply.
+ * @return New matrix.
+ */
+ public Matrix times(double x);
+
+ /**
+ * Creates new matrix that is the product of multiplying this matrix and the argument matrix.
+ *
+ * @param mtx Argument matrix.
+ * @return New matrix.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Matrix times(Matrix mtx);
+
+ /**
+ * Creates new matrix that is the product of multiplying this matrix and the argument vector.
+ *
+ * @param vec Argument vector.
+ * @return New matrix.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector times(Vector vec);
+
+ /**
+ * Gets maximum absolute row sum norm of this matrix.
+ * See http://mathworld.wolfram.com/MaximumAbsoluteRowSumNorm.html
+ *
+ * @return Maximum absolute row sum norm of this matrix.
+ */
+ public double maxAbsRowSumNorm();
+
+ /**
+ * Gets sum of all elements in the matrix.
+ *
+ * @return Sum of all elements in this matrix.
+ */
+ public double sum();
+
+ /**
+ * Creates new matrix that is transpose of this matrix.
+ *
+ * @return New transposed matrix.
+ */
+ public Matrix transpose();
+
+ /**
+ * Creates new view into this matrix. Changes to the view will be propagated to this matrix.
+ *
+ * @param off View offset as <code>int[x,y]</code>.
+ * @param size View size as <code>int[rows, cols]</code>
+ * @return New view.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ * @throws IndexException Thrown in case of offset is out of bound.
+ */
+ public Matrix viewPart(int[] off, int[] size);
+
+ /**
+ * Creates new view into this matrix. Changes to the view will be propagated to this matrix.
+ *
+ * @param rowOff
+ * @param rows
+ * @param colOff
+ * @param cols
+ * @return New view.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ * @throws IndexException Thrown in case of offset is out of bound.
+ */
+ public Matrix viewPart(int rowOff, int rows, int colOff, int cols);
+
+ /**
+ * Creates new view into matrix row. Changes to the view will be propagated to this matrix.
+ *
+ * @param row Row index.
+ * @return New view.
+ * @throws IndexException Thrown in case of index is out of bound.
+ */
+ public Vector viewRow(int row);
+
+ /**
+ * Creates new view into matrix column . Changes to the view will be propagated to this matrix.
+ *
+ * @param col Column index.
+ * @return New view.
+ * @throws IndexException Thrown in case of index is out of bound.
+ */
+ public Vector viewColumn(int col);
+
+ /**
+ * Creates new view into matrix diagonal. Changes to the view will be propagated to this matrix.
+ *
+ * @return New view.
+ */
+ public Vector viewDiagonal();
+
+ /**
+ * Destroys matrix if managed outside of JVM. It's a no-op in all other cases.
+ */
+ public default void destroy() {
+ // No-op.
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java b/modules/ml/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java
new file mode 100644
index 0000000..d6ae06f
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/MatrixKeyMapper.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;
+
+/**
+ * Maps {@link Matrix} row and column index to cache key.
+ */
+public interface MatrixKeyMapper<K> extends KeyMapper<K> {
+ /**
+ * @param x Matrix row index.
+ * @param y Matrix column index.
+ * @return Cache key for given row and column.
+ */
+ public K apply(int x, int y);
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/MatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/MatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/MatrixStorage.java
new file mode 100644
index 0000000..11eced7
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/MatrixStorage.java
@@ -0,0 +1,58 @@
+/*
+ * 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;
+
+import java.io.Externalizable;
+
+/**
+ * Data storage support for {@link Matrix}.
+ */
+public interface MatrixStorage extends Externalizable, StorageOpsMetrics, Destroyable {
+ /**
+ * @param x Matrix row index.
+ * @param y Matrix column index.
+ * @return Value corresponding to given row and column.
+ */
+ public double get(int x, int y);
+
+ /**
+ * @param x Matrix row index.
+ * @param y Matrix column index.
+ * @param v Value to set at given row and column.
+ */
+ public void set(int x, int y, double v);
+
+ /**
+ *
+ */
+ public int columnSize();
+
+ /**
+ *
+ */
+ public int rowSize();
+
+ /**
+ * Gets underlying array if {@link StorageOpsMetrics#isArrayBased()} returns {@code true}.
+ *
+ * @see StorageOpsMetrics#isArrayBased()
+ */
+ default public double[][] data() {
+ return null;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/MetaAttributes.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/MetaAttributes.java b/modules/ml/src/main/java/org/apache/ignite/math/MetaAttributes.java
new file mode 100644
index 0000000..8973b55
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/MetaAttributes.java
@@ -0,0 +1,76 @@
+/*
+ * 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;
+
+import java.util.Map;
+
+/**
+ * Interface provides support for meta attributes on vectors and matrices.
+ */
+public interface MetaAttributes {
+ /**
+ * Implementation should return an instance of the map to store meta attributes.
+ */
+ public Map<String, Object> getMetaStorage();
+
+ /**
+ * Gets meta attribute with given name.
+ *
+ * @param name Name of the vector meta attribute to get.
+ * @param <T> Attribute's type.
+ */
+ @SuppressWarnings("unchecked")
+ public default <T> T getAttribute(String name) {
+ return (T)getMetaStorage().get(name);
+ }
+
+ /**
+ * Sets meta attribute with given name and value.
+ *
+ * @param name Name of the meta attribute.
+ * @param val Attribute value.
+ * @param <T> Attribute's type.
+ */
+ public default <T> void setAttribute(String name, T val) {
+ getMetaStorage().put(name, val);
+ }
+
+ /**
+ * Removes meta attribute with given name.
+ *
+ * @param name Name of the meta attribute.
+ * @return {@code true} if attribute was present and was removed, {@code false} otherwise.
+ */
+ public default boolean removeAttribute(String name) {
+ boolean is = getMetaStorage().containsKey(name);
+
+ if (is)
+ getMetaStorage().remove(name);
+
+ return is;
+ }
+
+ /**
+ * Checks if given meta attribute is present.
+ *
+ * @param name Attribute name to check.
+ */
+ public default boolean hasAttribute(String name) {
+ return getMetaStorage().containsKey(name);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/MurmurHash.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/MurmurHash.java b/modules/ml/src/main/java/org/apache/ignite/math/MurmurHash.java
new file mode 100644
index 0000000..3d1252e
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/MurmurHash.java
@@ -0,0 +1,246 @@
+/*
+ * 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;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * This is a very fast, non-cryptographic hash suitable for general hash-based lookup.
+ *
+ * See http://murmurhash.googlepages.com/ for mre details.
+ */
+public class MurmurHash {
+ /** Hide it. */
+ private MurmurHash() {
+ }
+
+ /**
+ * This produces exactly the same hash values as the final C+ version of MurmurHash3 and is
+ * thus suitable for producing the same hash values across platforms.
+ *
+ * The 32 bit x86 version of this hash should be the fastest variant for relatively short keys like IDs.
+ *
+ * Note - The x86 and x64 versions do _not_ produce the same results, as the algorithms are
+ * optimized for their respective platforms.
+ *
+ * See also http://github.com/yonik/java_util for future updates to this method.
+ *
+ * @param data
+ * @param off
+ * @param len
+ * @param seed
+ * @return 32 bit hash platform compatible with C++ MurmurHash3 implementation on x86.
+ */
+ public static int hash3X86(byte[] data, int off, int len, int seed) {
+ int c1 = 0xcc9e2d51;
+ int c2 = 0x1b873593;
+
+ int h1 = seed;
+ int roundedEnd = off + (len & 0xfffffffc); // Round down to 4 byte block.
+
+ for (int i = off; i < roundedEnd; i += 4) {
+ int k1 = (data[i] & 0xff) | ((data[i + 1] & 0xff) << 8) | ((data[i + 2] & 0xff) << 16) | (data[i + 3] << 24);
+
+ k1 *= c1;
+ k1 = (k1 << 15) | (k1 >>> 17);
+ k1 *= c2;
+
+ h1 ^= k1;
+ h1 = (h1 << 13) | (h1 >>> 19);
+ h1 = h1 * 5 + 0xe6546b64;
+ }
+
+ // Tail.
+ int k1 = 0;
+
+ switch (len & 0x03) {
+ case 3:
+ k1 = (data[roundedEnd + 2] & 0xff) << 16;
+ // Fallthrough - WTF?
+ case 2:
+ k1 |= (data[roundedEnd + 1] & 0xff) << 8;
+ // Fallthrough - WTF?
+ case 1:
+ k1 |= data[roundedEnd] & 0xff;
+ k1 *= c1;
+ k1 = (k1 << 15) | (k1 >>> 17);
+ k1 *= c2;
+ h1 ^= k1;
+ default:
+ }
+
+ // Finalization.
+ h1 ^= len;
+
+ h1 ^= h1 >>> 16;
+ h1 *= 0x85ebca6b;
+ h1 ^= h1 >>> 13;
+ h1 *= 0xc2b2ae35;
+ h1 ^= h1 >>> 16;
+
+ return h1;
+ }
+
+ /**
+ * Hashes an int.
+ *
+ * @param data The int to hash.
+ * @param seed The seed for the hash.
+ * @return The 32 bit hash of the bytes in question.
+ */
+ public static int hash(int data, int seed) {
+ byte[] arr = new byte[] {
+ (byte)(data >>> 24),
+ (byte)(data >>> 16),
+ (byte)(data >>> 8),
+ (byte)data
+ };
+
+ return hash(ByteBuffer.wrap(arr), seed);
+ }
+
+ /**
+ * Hashes bytes in an array.
+ *
+ * @param data The bytes to hash.
+ * @param seed The seed for the hash.
+ * @return The 32 bit hash of the bytes in question.
+ */
+ public static int hash(byte[] data, int seed) {
+ return hash(ByteBuffer.wrap(data), seed);
+ }
+
+ /**
+ * Hashes bytes in part of an array.
+ *
+ * @param data The data to hash.
+ * @param off Where to start munging.
+ * @param len How many bytes to process.
+ * @param seed The seed to start with.
+ * @return The 32-bit hash of the data in question.
+ */
+ public static int hash(byte[] data, int off, int len, int seed) {
+ return hash(ByteBuffer.wrap(data, off, len), seed);
+ }
+
+ /**
+ * Hashes the bytes in a buffer from the current position to the limit.
+ *
+ * @param buf The bytes to hash.
+ * @param seed The seed for the hash.
+ * @return The 32 bit murmur hash of the bytes in the buffer.
+ */
+ public static int hash(ByteBuffer buf, int seed) {
+ ByteOrder byteOrder = buf.order();
+ buf.order(ByteOrder.LITTLE_ENDIAN);
+
+ int m = 0x5bd1e995;
+ int r = 24;
+
+ int h = seed ^ buf.remaining();
+
+ while (buf.remaining() >= 4) {
+ int k = buf.getInt();
+
+ k *= m;
+ k ^= k >>> r;
+ k *= m;
+
+ h *= m;
+ h ^= k;
+ }
+
+ if (buf.remaining() > 0) {
+ ByteBuffer finish = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN);
+
+ finish.put(buf).rewind();
+
+ h ^= finish.getInt();
+ h *= m;
+ }
+
+ h ^= h >>> 13;
+ h *= m;
+ h ^= h >>> 15;
+
+ buf.order(byteOrder);
+
+ return h;
+ }
+
+ /**
+ * @param data
+ * @param seed
+ */
+ public static long hash64A(byte[] data, int seed) {
+ return hash64A(ByteBuffer.wrap(data), seed);
+ }
+
+ /**
+ * @param data
+ * @param off
+ * @param len
+ * @param seed
+ */
+ public static long hash64A(byte[] data, int off, int len, int seed) {
+ return hash64A(ByteBuffer.wrap(data, off, len), seed);
+ }
+
+ /**
+ * @param buf
+ * @param seed
+ */
+ public static long hash64A(ByteBuffer buf, int seed) {
+ ByteOrder byteOrder = buf.order();
+ buf.order(ByteOrder.LITTLE_ENDIAN);
+
+ long m = 0xc6a4a7935bd1e995L;
+ int r = 47;
+
+ long h = seed ^ (buf.remaining() * m);
+
+ while (buf.remaining() >= 8) {
+ long k = buf.getLong();
+
+ k *= m;
+ k ^= k >>> r;
+ k *= m;
+
+ h ^= k;
+ h *= m;
+ }
+
+ if (buf.remaining() > 0) {
+ ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
+
+ finish.put(buf).rewind();
+
+ h ^= finish.getLong();
+ h *= m;
+ }
+
+ h ^= h >>> r;
+ h *= m;
+ h ^= h >>> r;
+
+ buf.order(byteOrder);
+
+ return h;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/StorageConstants.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/StorageConstants.java b/modules/ml/src/main/java/org/apache/ignite/math/StorageConstants.java
new file mode 100644
index 0000000..e8bfdf6
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/StorageConstants.java
@@ -0,0 +1,49 @@
+/*
+ * 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;
+
+/**
+ * Support for different modes of accessing data storage.
+ */
+public interface StorageConstants {
+ /** Storage mode optimized for sequential access. */
+ public static final int SEQUENTIAL_ACCESS_MODE = 1001;
+
+ /** Storage mode optimized for random access. */
+ public static final int RANDOM_ACCESS_MODE = 1002;
+
+ /** Storage mode optimized for row access. */
+ public static final int ROW_STORAGE_MODE = 2001;
+
+ /** Storage mode optimized for column access. */
+ public static final int COLUMN_STORAGE_MODE = 2002;
+
+ /**
+ * @param mode Access mode to verify.
+ */
+ public default void assertAccessMode(int mode) {
+ assert mode == SEQUENTIAL_ACCESS_MODE || mode == RANDOM_ACCESS_MODE;
+ }
+
+ /**
+ * @param mode Storage mode to verify.
+ */
+ public default void assertStorageMode(int mode) {
+ assert mode == ROW_STORAGE_MODE || mode == COLUMN_STORAGE_MODE;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java b/modules/ml/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java
new file mode 100644
index 0000000..c3252ba
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java
@@ -0,0 +1,49 @@
+/*
+ * 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;
+
+/**
+ * Storage and operation cost characteristics.
+ */
+public interface StorageOpsMetrics {
+ /**
+ * Checks if this implementation should be considered to be iterable in index order in an efficient way.
+ */
+ public boolean isSequentialAccess();
+
+ /**
+ * Checks if this implementation is optimized for random access.
+ */
+ public boolean isRandomAccess();
+
+ /**
+ * Checks if this implementation should be considered dense so that it explicitly
+ * represents every value.
+ */
+ public boolean isDense();
+
+ /**
+ * Checks if implementation is based on Java arrays.
+ */
+ public boolean isArrayBased();
+
+ /**
+ * Checks whether implementation is JVM-local or distributed (multi-JVM).
+ */
+ public boolean isDistributed();
+}
[26/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
IGNITE-5000 Rename Ignite Math module to Ignite ML module
Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/732dfea9
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/732dfea9
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/732dfea9
Branch: refs/heads/master
Commit: 732dfea91ef6718bf22005f54debbb73c2160f2e
Parents: d95960b
Author: Yury Babak <yb...@gridgain.com>
Authored: Mon Apr 17 18:59:52 2017 +0300
Committer: Anton Vinogradov <av...@apache.org>
Committed: Mon Apr 17 18:59:54 2017 +0300
----------------------------------------------------------------------
examples/README.txt | 10 +-
examples/pom-standalone-lgpl.xml | 17 +-
examples/pom-standalone.xml | 17 +-
examples/pom.xml | 28 +-
.../CholeskyDecompositionExample.java | 80 --
.../EigenDecompositionExample.java | 69 --
.../decompositions/LUDecompositionExample.java | 83 --
.../SingularValueDecompositionExample.java | 70 --
.../java8/math/decompositions/package-info.java | 22 -
.../java8/math/matrix/CacheMatrixExample.java | 91 --
.../java8/math/matrix/ExampleMatrixStorage.java | 162 ---
.../math/matrix/MatrixCustomStorageExample.java | 141 ---
.../java8/math/matrix/MatrixExample.java | 79 --
.../java8/math/matrix/MatrixExampleUtil.java | 52 -
.../java8/math/matrix/OffHeapMatrixExample.java | 84 --
.../matrix/SparseDistributedMatrixExample.java | 65 -
.../java8/math/matrix/SparseMatrixExample.java | 84 --
.../java8/math/matrix/package-info.java | 22 -
.../examples/java8/math/package-info.java | 22 -
.../java8/math/tracer/TracerExample.java | 63 -
.../java8/math/tracer/package-info.java | 22 -
.../java8/math/vector/CacheVectorExample.java | 102 --
.../java8/math/vector/ExampleVectorStorage.java | 126 --
.../java8/math/vector/OffHeapVectorExample.java | 78 --
.../java8/math/vector/SparseVectorExample.java | 80 --
.../math/vector/VectorCustomStorageExample.java | 124 --
.../java8/math/vector/VectorExample.java | 75 --
.../java8/math/vector/package-info.java | 22 -
.../CholeskyDecompositionExample.java | 80 ++
.../EigenDecompositionExample.java | 69 ++
.../decompositions/LUDecompositionExample.java | 83 ++
.../SingularValueDecompositionExample.java | 70 ++
.../ml/math/decompositions/package-info.java | 22 +
.../ml/math/matrix/CacheMatrixExample.java | 91 ++
.../ml/math/matrix/ExampleMatrixStorage.java | 162 +++
.../math/matrix/MatrixCustomStorageExample.java | 141 +++
.../examples/ml/math/matrix/MatrixExample.java | 79 ++
.../ml/math/matrix/MatrixExampleUtil.java | 52 +
.../ml/math/matrix/OffHeapMatrixExample.java | 84 ++
.../matrix/SparseDistributedMatrixExample.java | 65 +
.../ml/math/matrix/SparseMatrixExample.java | 84 ++
.../examples/ml/math/matrix/package-info.java | 22 +
.../ignite/examples/ml/math/package-info.java | 22 +
.../examples/ml/math/tracer/TracerExample.java | 63 +
.../examples/ml/math/tracer/package-info.java | 22 +
.../ml/math/vector/CacheVectorExample.java | 102 ++
.../ml/math/vector/ExampleVectorStorage.java | 126 ++
.../ml/math/vector/OffHeapVectorExample.java | 78 ++
.../ml/math/vector/SparseVectorExample.java | 80 ++
.../math/vector/VectorCustomStorageExample.java | 124 ++
.../examples/ml/math/vector/VectorExample.java | 75 ++
.../examples/ml/math/vector/package-info.java | 22 +
modules/math/README.txt | 15 -
modules/math/licenses/apache-2.0.txt | 202 ----
modules/math/licenses/mit.txt | 7 -
modules/math/pom.xml | 109 --
.../java/org/apache/ignite/math/Algebra.java | 571 ---------
.../java/org/apache/ignite/math/Constants.java | 42 -
.../org/apache/ignite/math/Destroyable.java | 30 -
.../apache/ignite/math/IdentityValueMapper.java | 53 -
.../java/org/apache/ignite/math/KeyMapper.java | 33 -
.../java/org/apache/ignite/math/Matrix.java | 518 --------
.../org/apache/ignite/math/MatrixKeyMapper.java | 30 -
.../org/apache/ignite/math/MatrixStorage.java | 58 -
.../org/apache/ignite/math/MetaAttributes.java | 76 --
.../java/org/apache/ignite/math/MurmurHash.java | 246 ----
.../apache/ignite/math/StorageConstants.java | 49 -
.../apache/ignite/math/StorageOpsMetrics.java | 49 -
.../java/org/apache/ignite/math/Tracer.java | 456 -------
.../org/apache/ignite/math/ValueMapper.java | 27 -
.../java/org/apache/ignite/math/Vector.java | 498 --------
.../org/apache/ignite/math/VectorKeyMapper.java | 29 -
.../org/apache/ignite/math/VectorStorage.java | 53 -
.../decompositions/CholeskyDecomposition.java | 306 -----
.../decompositions/DecompositionSupport.java | 105 --
.../math/decompositions/EigenDecomposition.java | 923 ---------------
.../math/decompositions/LUDecomposition.java | 366 ------
.../math/decompositions/QRDecomposition.java | 186 ---
.../SingularValueDecomposition.java | 620 ----------
.../math/decompositions/package-info.java | 22 -
.../math/exceptions/CardinalityException.java | 38 -
.../math/exceptions/ColumnIndexException.java | 35 -
.../ignite/math/exceptions/IndexException.java | 35 -
.../NonPositiveDefiniteMatrixException.java | 20 -
.../exceptions/NonSymmetricMatrixException.java | 18 -
.../math/exceptions/RowIndexException.java | 35 -
.../exceptions/SingularMatrixException.java | 30 -
.../exceptions/UnknownProviderException.java | 35 -
.../UnsupportedOperationException.java | 44 -
.../ignite/math/exceptions/package-info.java | 22 -
.../apache/ignite/math/functions/Functions.java | 136 ---
.../ignite/math/functions/IgniteBiConsumer.java | 12 -
.../ignite/math/functions/IgniteBiFunction.java | 29 -
.../ignite/math/functions/IgniteConsumer.java | 29 -
.../math/functions/IgniteDoubleFunction.java | 29 -
.../ignite/math/functions/IgniteFunction.java | 30 -
.../math/functions/IntDoubleToVoidFunction.java | 25 -
.../functions/IntIntDoubleToVoidFunction.java | 28 -
.../math/functions/IntIntToDoubleFunction.java | 24 -
.../ignite/math/functions/package-info.java | 22 -
.../apache/ignite/math/impls/CacheUtils.java | 356 ------
.../math/impls/matrix/AbstractMatrix.java | 880 --------------
.../ignite/math/impls/matrix/CacheMatrix.java | 158 ---
.../impls/matrix/DenseLocalOffHeapMatrix.java | 90 --
.../impls/matrix/DenseLocalOnHeapMatrix.java | 86 --
.../math/impls/matrix/DiagonalMatrix.java | 101 --
.../math/impls/matrix/FunctionMatrix.java | 95 --
.../ignite/math/impls/matrix/MatrixView.java | 84 --
.../math/impls/matrix/PivotedMatrixView.java | 243 ----
.../ignite/math/impls/matrix/RandomMatrix.java | 97 --
.../impls/matrix/SparseDistributedMatrix.java | 155 ---
.../impls/matrix/SparseLocalOnHeapMatrix.java | 72 --
.../math/impls/matrix/TransposedMatrixView.java | 84 --
.../ignite/math/impls/matrix/package-info.java | 22 -
.../apache/ignite/math/impls/package-info.java | 22 -
.../storage/matrix/ArrayMatrixStorage.java | 161 ---
.../storage/matrix/CacheMatrixStorage.java | 180 ---
.../matrix/DenseOffHeapMatrixStorage.java | 197 ----
.../storage/matrix/DiagonalMatrixStorage.java | 136 ---
.../storage/matrix/FunctionMatrixStorage.java | 175 ---
.../storage/matrix/MatrixDelegateStorage.java | 205 ----
.../storage/matrix/PivotedMatrixStorage.java | 256 ----
.../storage/matrix/RandomMatrixStorage.java | 176 ---
.../matrix/SparseDistributedMatrixStorage.java | 281 -----
.../matrix/SparseLocalOnHeapMatrixStorage.java | 226 ----
.../math/impls/storage/matrix/package-info.java | 22 -
.../storage/vector/ArrayVectorStorage.java | 135 ---
.../storage/vector/CacheVectorStorage.java | 175 ---
.../storage/vector/ConstantVectorStorage.java | 133 ---
.../storage/vector/DelegateVectorStorage.java | 157 ---
.../vector/DenseLocalOffHeapVectorStorage.java | 172 ---
.../storage/vector/FunctionVectorStorage.java | 141 ---
.../storage/vector/MatrixVectorStorage.java | 185 ---
.../storage/vector/PivotedVectorStorage.java | 175 ---
.../storage/vector/RandomVectorStorage.java | 152 ---
.../SingleElementVectorDelegateStorage.java | 145 ---
.../vector/SingleElementVectorStorage.java | 143 ---
.../vector/SparseLocalOffHeapVectorStorage.java | 148 ---
.../vector/SparseLocalOnHeapVectorStorage.java | 152 ---
.../math/impls/storage/vector/package-info.java | 22 -
.../impls/vector/AbstractReadOnlyVector.java | 108 --
.../math/impls/vector/AbstractVector.java | 903 --------------
.../ignite/math/impls/vector/CacheVector.java | 140 ---
.../math/impls/vector/ConstantVector.java | 84 --
.../math/impls/vector/DelegatingVector.java | 391 ------
.../impls/vector/DenseLocalOffHeapVector.java | 89 --
.../impls/vector/DenseLocalOnHeapVector.java | 104 --
.../math/impls/vector/FunctionVector.java | 112 --
.../math/impls/vector/MatrixVectorView.java | 139 ---
.../math/impls/vector/PivotedVectorView.java | 163 ---
.../ignite/math/impls/vector/RandomVector.java | 128 --
.../math/impls/vector/SingleElementVector.java | 102 --
.../impls/vector/SingleElementVectorView.java | 97 --
.../impls/vector/SparseLocalOffHeapVector.java | 47 -
.../math/impls/vector/SparseLocalVector.java | 71 --
.../ignite/math/impls/vector/VectorView.java | 85 --
.../ignite/math/impls/vector/package-info.java | 22 -
.../org/apache/ignite/math/package-info.java | 22 -
.../apache/ignite/math/d3-matrix-template.html | 128 --
.../apache/ignite/math/d3-vector-template.html | 111 --
.../org/apache/ignite/math/ExternalizeTest.java | 66 --
.../math/MathImplDistributedTestSuite.java | 39 -
.../ignite/math/MathImplLocalTestSuite.java | 123 --
.../ignite/math/MathImplMainTestSuite.java | 33 -
.../java/org/apache/ignite/math/TracerTest.java | 195 ---
.../ignite/math/benchmark/MathBenchmark.java | 205 ----
.../math/benchmark/MathBenchmarkSelfTest.java | 100 --
.../ignite/math/benchmark/ResultsWriter.java | 127 --
.../math/benchmark/VectorBenchmarkTest.java | 138 ---
.../ignite/math/benchmark/package-info.java | 18 -
.../CholeskyDecompositionTest.java | 158 ---
.../decompositions/EigenDecompositionTest.java | 193 ---
.../decompositions/LUDecompositionTest.java | 250 ----
.../decompositions/QRDecompositionTest.java | 139 ---
.../SingularValueDecompositionTest.java | 120 --
.../ignite/math/impls/MathTestConstants.java | 88 --
.../math/impls/matrix/CacheMatrixTest.java | 369 ------
.../DenseLocalOffHeapMatrixConstructorTest.java | 65 -
.../DenseLocalOnHeapMatrixConstructorTest.java | 71 --
.../math/impls/matrix/DiagonalMatrixTest.java | 209 ----
.../matrix/FunctionMatrixConstructorTest.java | 113 --
.../math/impls/matrix/MatrixAttributeTest.java | 156 ---
.../matrix/MatrixImplementationFixtures.java | 381 ------
.../impls/matrix/MatrixImplementationsTest.java | 1113 ------------------
.../impls/matrix/MatrixKeyMapperForTests.java | 69 --
.../impls/matrix/MatrixViewConstructorTest.java | 114 --
.../PivotedMatrixViewConstructorTest.java | 128 --
.../matrix/RandomMatrixConstructorTest.java | 71 --
.../matrix/SparseDistributedMatrixTest.java | 265 -----
.../SparseLocalOnHeapMatrixConstructorTest.java | 53 -
.../impls/matrix/TransposedMatrixViewTest.java | 87 --
.../storage/matrix/MatrixArrayStorageTest.java | 63 -
.../storage/matrix/MatrixBaseStorageTest.java | 89 --
.../matrix/MatrixOffHeapStorageTest.java | 39 -
.../storage/matrix/MatrixStorageFixtures.java | 141 ---
.../matrix/MatrixStorageImplementationTest.java | 73 --
.../SparseDistributedMatrixStorageTest.java | 126 --
.../RandomAccessSparseVectorStorageTest.java | 60 -
.../SparseLocalOffHeapVectorStorageTest.java | 78 --
.../storage/vector/VectorArrayStorageTest.java | 58 -
.../storage/vector/VectorBaseStorageTest.java | 69 --
.../vector/VectorOffheapStorageTest.java | 73 --
.../math/impls/vector/AbstractVectorTest.java | 543 ---------
.../math/impls/vector/CacheVectorTest.java | 417 -------
.../vector/ConstantVectorConstructorTest.java | 52 -
.../vector/DelegatingVectorConstructorTest.java | 62 -
.../DenseLocalOffHeapVectorConstructorTest.java | 59 -
.../DenseLocalOnHeapVectorConstructorTest.java | 163 ---
.../vector/FunctionVectorConstructorTest.java | 121 --
.../math/impls/vector/MatrixVectorViewTest.java | 209 ----
.../PivotedVectorViewConstructorTest.java | 211 ----
.../vector/RandomVectorConstructorTest.java | 145 ---
.../SingleElementVectorConstructorTest.java | 159 ---
.../SingleElementVectorViewConstructorTest.java | 137 ---
.../SparseLocalVectorConstructorTest.java | 54 -
.../math/impls/vector/VectorAttributesTest.java | 217 ----
.../math/impls/vector/VectorFoldMapTest.java | 122 --
.../vector/VectorImplementationsFixtures.java | 655 -----------
.../impls/vector/VectorImplementationsTest.java | 860 --------------
.../math/impls/vector/VectorIterableTest.java | 376 ------
.../math/impls/vector/VectorNormTest.java | 247 ----
.../math/impls/vector/VectorToMatrixTest.java | 291 -----
.../math/impls/vector/VectorViewTest.java | 162 ---
modules/ml/README.txt | 15 +
modules/ml/licenses/apache-2.0.txt | 202 ++++
modules/ml/licenses/mit.txt | 7 +
modules/ml/pom.xml | 109 ++
.../java/org/apache/ignite/math/Algebra.java | 571 +++++++++
.../java/org/apache/ignite/math/Constants.java | 42 +
.../org/apache/ignite/math/Destroyable.java | 30 +
.../apache/ignite/math/IdentityValueMapper.java | 53 +
.../java/org/apache/ignite/math/KeyMapper.java | 33 +
.../java/org/apache/ignite/math/Matrix.java | 518 ++++++++
.../org/apache/ignite/math/MatrixKeyMapper.java | 30 +
.../org/apache/ignite/math/MatrixStorage.java | 58 +
.../org/apache/ignite/math/MetaAttributes.java | 76 ++
.../java/org/apache/ignite/math/MurmurHash.java | 246 ++++
.../apache/ignite/math/StorageConstants.java | 49 +
.../apache/ignite/math/StorageOpsMetrics.java | 49 +
.../java/org/apache/ignite/math/Tracer.java | 456 +++++++
.../org/apache/ignite/math/ValueMapper.java | 27 +
.../java/org/apache/ignite/math/Vector.java | 498 ++++++++
.../org/apache/ignite/math/VectorKeyMapper.java | 29 +
.../org/apache/ignite/math/VectorStorage.java | 53 +
.../decompositions/CholeskyDecomposition.java | 306 +++++
.../decompositions/DecompositionSupport.java | 105 ++
.../math/decompositions/EigenDecomposition.java | 923 +++++++++++++++
.../math/decompositions/LUDecomposition.java | 366 ++++++
.../math/decompositions/QRDecomposition.java | 186 +++
.../SingularValueDecomposition.java | 620 ++++++++++
.../math/decompositions/package-info.java | 22 +
.../math/exceptions/CardinalityException.java | 38 +
.../math/exceptions/ColumnIndexException.java | 35 +
.../ignite/math/exceptions/IndexException.java | 35 +
.../NonPositiveDefiniteMatrixException.java | 20 +
.../exceptions/NonSymmetricMatrixException.java | 18 +
.../math/exceptions/RowIndexException.java | 35 +
.../exceptions/SingularMatrixException.java | 30 +
.../exceptions/UnknownProviderException.java | 35 +
.../UnsupportedOperationException.java | 44 +
.../ignite/math/exceptions/package-info.java | 22 +
.../apache/ignite/math/functions/Functions.java | 136 +++
.../ignite/math/functions/IgniteBiConsumer.java | 12 +
.../ignite/math/functions/IgniteBiFunction.java | 29 +
.../ignite/math/functions/IgniteConsumer.java | 29 +
.../math/functions/IgniteDoubleFunction.java | 29 +
.../ignite/math/functions/IgniteFunction.java | 30 +
.../math/functions/IntDoubleToVoidFunction.java | 25 +
.../functions/IntIntDoubleToVoidFunction.java | 28 +
.../math/functions/IntIntToDoubleFunction.java | 24 +
.../ignite/math/functions/package-info.java | 22 +
.../apache/ignite/math/impls/CacheUtils.java | 356 ++++++
.../math/impls/matrix/AbstractMatrix.java | 880 ++++++++++++++
.../ignite/math/impls/matrix/CacheMatrix.java | 158 +++
.../impls/matrix/DenseLocalOffHeapMatrix.java | 90 ++
.../impls/matrix/DenseLocalOnHeapMatrix.java | 86 ++
.../math/impls/matrix/DiagonalMatrix.java | 101 ++
.../math/impls/matrix/FunctionMatrix.java | 95 ++
.../ignite/math/impls/matrix/MatrixView.java | 84 ++
.../math/impls/matrix/PivotedMatrixView.java | 243 ++++
.../ignite/math/impls/matrix/RandomMatrix.java | 97 ++
.../impls/matrix/SparseDistributedMatrix.java | 155 +++
.../impls/matrix/SparseLocalOnHeapMatrix.java | 72 ++
.../math/impls/matrix/TransposedMatrixView.java | 84 ++
.../ignite/math/impls/matrix/package-info.java | 22 +
.../apache/ignite/math/impls/package-info.java | 22 +
.../storage/matrix/ArrayMatrixStorage.java | 161 +++
.../storage/matrix/CacheMatrixStorage.java | 180 +++
.../matrix/DenseOffHeapMatrixStorage.java | 197 ++++
.../storage/matrix/DiagonalMatrixStorage.java | 136 +++
.../storage/matrix/FunctionMatrixStorage.java | 175 +++
.../storage/matrix/MatrixDelegateStorage.java | 205 ++++
.../storage/matrix/PivotedMatrixStorage.java | 256 ++++
.../storage/matrix/RandomMatrixStorage.java | 176 +++
.../matrix/SparseDistributedMatrixStorage.java | 281 +++++
.../matrix/SparseLocalOnHeapMatrixStorage.java | 226 ++++
.../math/impls/storage/matrix/package-info.java | 22 +
.../storage/vector/ArrayVectorStorage.java | 135 +++
.../storage/vector/CacheVectorStorage.java | 175 +++
.../storage/vector/ConstantVectorStorage.java | 133 +++
.../storage/vector/DelegateVectorStorage.java | 157 +++
.../vector/DenseLocalOffHeapVectorStorage.java | 172 +++
.../storage/vector/FunctionVectorStorage.java | 141 +++
.../storage/vector/MatrixVectorStorage.java | 185 +++
.../storage/vector/PivotedVectorStorage.java | 175 +++
.../storage/vector/RandomVectorStorage.java | 152 +++
.../SingleElementVectorDelegateStorage.java | 145 +++
.../vector/SingleElementVectorStorage.java | 143 +++
.../vector/SparseLocalOffHeapVectorStorage.java | 148 +++
.../vector/SparseLocalOnHeapVectorStorage.java | 152 +++
.../math/impls/storage/vector/package-info.java | 22 +
.../impls/vector/AbstractReadOnlyVector.java | 108 ++
.../math/impls/vector/AbstractVector.java | 903 ++++++++++++++
.../ignite/math/impls/vector/CacheVector.java | 140 +++
.../math/impls/vector/ConstantVector.java | 84 ++
.../math/impls/vector/DelegatingVector.java | 391 ++++++
.../impls/vector/DenseLocalOffHeapVector.java | 89 ++
.../impls/vector/DenseLocalOnHeapVector.java | 104 ++
.../math/impls/vector/FunctionVector.java | 112 ++
.../math/impls/vector/MatrixVectorView.java | 139 +++
.../math/impls/vector/PivotedVectorView.java | 163 +++
.../ignite/math/impls/vector/RandomVector.java | 128 ++
.../math/impls/vector/SingleElementVector.java | 102 ++
.../impls/vector/SingleElementVectorView.java | 97 ++
.../impls/vector/SparseLocalOffHeapVector.java | 47 +
.../math/impls/vector/SparseLocalVector.java | 71 ++
.../ignite/math/impls/vector/VectorView.java | 85 ++
.../ignite/math/impls/vector/package-info.java | 22 +
.../org/apache/ignite/math/package-info.java | 22 +
.../apache/ignite/math/d3-matrix-template.html | 128 ++
.../apache/ignite/math/d3-vector-template.html | 111 ++
.../org/apache/ignite/math/ExternalizeTest.java | 66 ++
.../math/MathImplDistributedTestSuite.java | 39 +
.../ignite/math/MathImplLocalTestSuite.java | 123 ++
.../ignite/math/MathImplMainTestSuite.java | 33 +
.../java/org/apache/ignite/math/TracerTest.java | 195 +++
.../ignite/math/benchmark/MathBenchmark.java | 205 ++++
.../math/benchmark/MathBenchmarkSelfTest.java | 100 ++
.../ignite/math/benchmark/ResultsWriter.java | 127 ++
.../math/benchmark/VectorBenchmarkTest.java | 138 +++
.../ignite/math/benchmark/package-info.java | 18 +
.../CholeskyDecompositionTest.java | 158 +++
.../decompositions/EigenDecompositionTest.java | 193 +++
.../decompositions/LUDecompositionTest.java | 250 ++++
.../decompositions/QRDecompositionTest.java | 139 +++
.../SingularValueDecompositionTest.java | 120 ++
.../ignite/math/impls/MathTestConstants.java | 88 ++
.../math/impls/matrix/CacheMatrixTest.java | 369 ++++++
.../DenseLocalOffHeapMatrixConstructorTest.java | 65 +
.../DenseLocalOnHeapMatrixConstructorTest.java | 71 ++
.../math/impls/matrix/DiagonalMatrixTest.java | 209 ++++
.../matrix/FunctionMatrixConstructorTest.java | 113 ++
.../math/impls/matrix/MatrixAttributeTest.java | 156 +++
.../matrix/MatrixImplementationFixtures.java | 381 ++++++
.../impls/matrix/MatrixImplementationsTest.java | 1113 ++++++++++++++++++
.../impls/matrix/MatrixKeyMapperForTests.java | 69 ++
.../impls/matrix/MatrixViewConstructorTest.java | 114 ++
.../PivotedMatrixViewConstructorTest.java | 128 ++
.../matrix/RandomMatrixConstructorTest.java | 71 ++
.../matrix/SparseDistributedMatrixTest.java | 265 +++++
.../SparseLocalOnHeapMatrixConstructorTest.java | 53 +
.../impls/matrix/TransposedMatrixViewTest.java | 87 ++
.../storage/matrix/MatrixArrayStorageTest.java | 63 +
.../storage/matrix/MatrixBaseStorageTest.java | 89 ++
.../matrix/MatrixOffHeapStorageTest.java | 39 +
.../storage/matrix/MatrixStorageFixtures.java | 141 +++
.../matrix/MatrixStorageImplementationTest.java | 73 ++
.../SparseDistributedMatrixStorageTest.java | 126 ++
.../RandomAccessSparseVectorStorageTest.java | 60 +
.../SparseLocalOffHeapVectorStorageTest.java | 78 ++
.../storage/vector/VectorArrayStorageTest.java | 58 +
.../storage/vector/VectorBaseStorageTest.java | 69 ++
.../vector/VectorOffheapStorageTest.java | 73 ++
.../math/impls/vector/AbstractVectorTest.java | 543 +++++++++
.../math/impls/vector/CacheVectorTest.java | 417 +++++++
.../vector/ConstantVectorConstructorTest.java | 52 +
.../vector/DelegatingVectorConstructorTest.java | 62 +
.../DenseLocalOffHeapVectorConstructorTest.java | 59 +
.../DenseLocalOnHeapVectorConstructorTest.java | 163 +++
.../vector/FunctionVectorConstructorTest.java | 121 ++
.../math/impls/vector/MatrixVectorViewTest.java | 209 ++++
.../PivotedVectorViewConstructorTest.java | 211 ++++
.../vector/RandomVectorConstructorTest.java | 145 +++
.../SingleElementVectorConstructorTest.java | 159 +++
.../SingleElementVectorViewConstructorTest.java | 137 +++
.../SparseLocalVectorConstructorTest.java | 54 +
.../math/impls/vector/VectorAttributesTest.java | 217 ++++
.../math/impls/vector/VectorFoldMapTest.java | 122 ++
.../vector/VectorImplementationsFixtures.java | 655 +++++++++++
.../impls/vector/VectorImplementationsTest.java | 860 ++++++++++++++
.../math/impls/vector/VectorIterableTest.java | 376 ++++++
.../math/impls/vector/VectorNormTest.java | 247 ++++
.../math/impls/vector/VectorToMatrixTest.java | 291 +++++
.../math/impls/vector/VectorViewTest.java | 162 +++
pom.xml | 4 +-
395 files changed, 29271 insertions(+), 29207 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/README.txt
----------------------------------------------------------------------
diff --git a/examples/README.txt b/examples/README.txt
index a17c9c8..6f69481 100644
--- a/examples/README.txt
+++ b/examples/README.txt
@@ -16,7 +16,7 @@ The examples folder contains he following subfolders:
are excluded by default, enable `java8` Maven profile to include them (JDK8 is required).
- `src/main/scala` - contains examples demonstrating usage of API provided by Scalar.
- `src/main/java-lgpl` - contains lgpl-based examples for different Ignite modules and features.
-
+- `src/main/ml` - contains Java examples for Ignite-ML module.
Starting Remote Nodes
=====================
@@ -47,3 +47,11 @@ This case will install lgpl-based libs to local maven repository.
2) Run "mvn clean package -DskipTests -Prelease,lgpl -Dignite.edition=fabric-lgpl" at Apache Ignite sources.
Required libs will appear at /target/release-package/libs/optional subfolders.
Found libs should be copied to global or project's classpath.
+
+ML
+==
+Math/Machine Learning examples can be activated by turning ml profile on.
+
+This module also required java8 and ignite-ml module.
+
+Like the lgpl examples we could build required module running "mvn clean install -Pml -DskipTests -pl modules/ml -am".
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/pom-standalone-lgpl.xml
----------------------------------------------------------------------
diff --git a/examples/pom-standalone-lgpl.xml b/examples/pom-standalone-lgpl.xml
index d059390..2b4ece0 100644
--- a/examples/pom-standalone-lgpl.xml
+++ b/examples/pom-standalone-lgpl.xml
@@ -33,6 +33,7 @@
<lgpl.folder>src/main/java</lgpl.folder>
<java8.folder>src/main/java</java8.folder>
<spark.folder>src/main/java</spark.folder>
+ <ml.folder>src/main/java</ml.folder>
<java.ver>1.7</java.ver>
</properties>
@@ -102,11 +103,24 @@
<activation>
<jdk>[1.8,)</jdk>
</activation>
+ </profile>
+
+ <profile>
+ <id>ml</id>
+
+ <properties>
+ <ml.folder>src/main/ml</ml.folder>
+ <java.ver>1.8</java.ver>
+ </properties>
+
+ <activation>
+ <jdk>[1.8,)</jdk>
+ </activation>
<dependencies>
<dependency>
<groupId>org.apache.ignite</groupId>
- <artifactId>ignite-math</artifactId>
+ <artifactId>ignite-ml</artifactId>
<version>to_be_replaced_by_ignite_version</version>
</dependency>
</dependencies>
@@ -238,6 +252,7 @@
<source>${lgpl.folder}</source>
<source>${java8.folder}</source>
<source>${spark.folder}</source>
+ <source>${ml.folder}</source>
</sources>
</configuration>
</execution>
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/pom-standalone.xml
----------------------------------------------------------------------
diff --git a/examples/pom-standalone.xml b/examples/pom-standalone.xml
index ce41899..64b4301 100644
--- a/examples/pom-standalone.xml
+++ b/examples/pom-standalone.xml
@@ -33,6 +33,7 @@
<lgpl.folder>src/main/java</lgpl.folder>
<java8.folder>src/main/java</java8.folder>
<spark.folder>src/main/java</spark.folder>
+ <ml.folder>src/main/java</ml.folder>
<java.ver>1.7</java.ver>
</properties>
@@ -102,11 +103,24 @@
<activation>
<jdk>[1.8,)</jdk>
</activation>
+ </profile>
+
+ <profile>
+ <id>ml</id>
+
+ <properties>
+ <ml.folder>src/main/ml</ml.folder>
+ <java.ver>1.8</java.ver>
+ </properties>
+
+ <activation>
+ <jdk>[1.8,)</jdk>
+ </activation>
<dependencies>
<dependency>
<groupId>org.apache.ignite</groupId>
- <artifactId>ignite-math</artifactId>
+ <artifactId>ignite-ml</artifactId>
<version>to_be_replaced_by_ignite_version</version>
</dependency>
</dependencies>
@@ -239,6 +253,7 @@
<source>${lgpl.folder}</source>
<source>${java8.folder}</source>
<source>${spark.folder}</source>
+ <source>${ml.folder}</source>
</sources>
</configuration>
</execution>
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/pom.xml
----------------------------------------------------------------------
diff --git a/examples/pom.xml b/examples/pom.xml
index 88c3107..b933385 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -119,6 +119,7 @@
<lgpl.folder>src/main/java</lgpl.folder>
<java8.folder>src/main/java</java8.folder>
<spark.folder>src/main/java</spark.folder>
+ <ml.folder>src/main/java</ml.folder>
<spark.test.folder>src/test/java</spark.test.folder>
<lgpl.test.folder>src/test/java</lgpl.test.folder>
<java8.test.folder>src/test/java</java8.test.folder>
@@ -250,11 +251,35 @@
</plugin>
</plugins>
</build>
+ </profile>
+
+ <profile>
+ <id>ml</id>
+
+ <properties>
+ <ml.folder>src/main/ml</ml.folder>
+ </properties>
+
+ <activation>
+ <jdk>[1.8,)</jdk>
+ </activation>
+
+ <build>
+ <plugins>
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
<dependencies>
<dependency>
<groupId>org.apache.ignite</groupId>
- <artifactId>ignite-math</artifactId>
+ <artifactId>ignite-ml</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
@@ -299,6 +324,7 @@
<source>${lgpl.folder}</source>
<source>${java8.folder}</source>
<source>${spark.folder}</source>
+ <source>${ml.folder}</source>
</sources>
</configuration>
</execution>
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/CholeskyDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/CholeskyDecompositionExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/CholeskyDecompositionExample.java
deleted file mode 100644
index 9a68e28..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/CholeskyDecompositionExample.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * 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.examples.java8.math.decompositions;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Tracer;
-import org.apache.ignite.math.decompositions.CholeskyDecomposition;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-
-/**
- * Example of using {@link CholeskyDecomposition}.
- */
-public class CholeskyDecompositionExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println(">>> Cholesky decomposition example started.");
- // Let's compute a Cholesky decomposition of Hermitian matrix m:
- // m = l l^{*}, where
- // l is a lower triangular matrix
- // l^{*} is its conjugate transpose
-
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
- {2.0d, -1.0d, 0.0d},
- {-1.0d, 2.0d, -1.0d},
- {0.0d, -1.0d, 2.0d}
- });
- System.out.println("\n>>> Matrix m for decomposition: ");
- Tracer.showAscii(m);
-
- // This decomposition is useful when dealing with systems of linear equations of the form
- // m x = b where m is a Hermitian matrix.
- // For such systems Cholesky decomposition provides
- // more effective method of solving compared to LU decomposition.
- // Suppose we want to solve system
- // m x = b for various bs. Then after we computed Cholesky decomposition, we can feed various bs
- // as a matrix of the form
- // (b1, b2, ..., bm)
- // to the method Cholesky::solve which returns solutions in the form
- // (sol1, sol2, ..., solm)
- CholeskyDecomposition dec = new CholeskyDecomposition(m);
- System.out.println("\n>>> Made decomposition m = l * l^{*}.");
- System.out.println(">>> Matrix l is ");
- Tracer.showAscii(dec.getL());
- System.out.println(">>> Matrix l^{*} is ");
- Tracer.showAscii(dec.getLT());
-
- Matrix bs = new DenseLocalOnHeapMatrix(new double[][] {
- {4.0, -6.0, 7.0},
- {1.0, 1.0, 1.0}
- }).transpose();
- System.out.println("\n>>> Solving systems of linear equations of the form m x = b for various bs represented by columns of matrix");
- Tracer.showAscii(bs);
- Matrix sol = dec.solve(bs);
-
- System.out.println("\n>>> List of solutions: ");
- for (int i = 0; i < sol.columnSize(); i++)
- Tracer.showAscii(sol.viewColumn(i));
-
- System.out.println("\n>>> Cholesky decomposition example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/EigenDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/EigenDecompositionExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/EigenDecompositionExample.java
deleted file mode 100644
index e11d642..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/EigenDecompositionExample.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * 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.examples.java8.math.decompositions;
-
-import org.apache.ignite.math.Tracer;
-import org.apache.ignite.math.decompositions.EigenDecomposition;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-
-/**
- * Example of using {@link EigenDecomposition}.
- */
-public class EigenDecompositionExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println(">>> Eigen decomposition example started.");
-
- // Let's compute EigenDecomposition for some square (n x n) matrix m with real eigenvalues:
- // m = v d v^{-1}, where d is diagonal matrix having eigenvalues of m on diagonal
- // and v is matrix where i-th column is eigenvector for i-th eigenvalue (i from 0 to n - 1)
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
- {1.0d, 0.0d, 0.0d, 0.0d},
- {0.0d, 1.0d, 0.0d, 0.0d},
- {0.0d, 0.0d, 2.0d, 0.0d},
- {1.0d, 1.0d, 0.0d, 2.0d}
- });
- System.out.println("\n>>> Matrix m for decomposition: ");
- Tracer.showAscii(m);
-
- EigenDecomposition dec = new EigenDecomposition(m);
- System.out.println("\n>>> Made decomposition.");
- System.out.println(">>> Matrix getV is ");
- Tracer.showAscii(dec.getV());
- System.out.println(">>> Matrix getD is ");
- Tracer.showAscii(dec.getD());
-
- // From this decomposition we, for example, can easily compute determinant of matrix m
- // det (m) = det (v d v^{-1}) =
- // det(v) det (d) det(v^{-1}) =
- // det(v) det(v)^{-1} det(d) =
- // det (d) =
- // product of diagonal elements of d =
- // product of eigenvalues
- double det = dec.getRealEigenValues().foldMap(Functions.MULT, Functions.IDENTITY, 1.0);
- System.out.println("\n>>> Determinant is " + det);
-
- System.out.println("\n>>> Eigen decomposition example completed.");
- }
-
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/LUDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/LUDecompositionExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/LUDecompositionExample.java
deleted file mode 100644
index bf005ec..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/LUDecompositionExample.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * 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.examples.java8.math.decompositions;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Tracer;
-import org.apache.ignite.math.decompositions.LUDecomposition;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-
-/**
- * Example of using {@link LUDecomposition}.
- */
-public class LUDecompositionExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println(">>> LU decomposition example started.");
- // Let's compute a LU decomposition for some (n x n) matrix m:
- // m = p l u, where
- // p is an (n x n) is a row-permutation matrix
- // l is a (n x n) lower triangular matrix
- // u is a (n x n) upper triangular matrix
-
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
- {1.0d, 1.0d, -1.0d},
- {1.0d, -2.0d, 3.0d},
- {2.0d, 3.0d, 1.0d}
- });
- System.out.println("\n>>> Matrix m for decomposition: ");
- Tracer.showAscii(m);
-
- // This decomposition is useful when dealing with systems of linear equations.
- // (see https://en.wikipedia.org/wiki/LU_decomposition)
- // suppose we want to solve system
- // m x = b for various bs. Then after we computed LU decomposition, we can feed various bs
- // as a matrix of the form
- // (b1, b2, ..., bm)
- // to the method LUDecomposition::solve which returns solutions in the form
- // (sol1, sol2, ..., solm)
-
- LUDecomposition dec = new LUDecomposition(m);
- System.out.println("\n>>> Made decomposition.");
- System.out.println(">>> Matrix getL is ");
- Tracer.showAscii(dec.getL());
- System.out.println(">>> Matrix getU is ");
- Tracer.showAscii(dec.getU());
- System.out.println(">>> Matrix getP is ");
- Tracer.showAscii(dec.getP());
-
- Matrix bs = new DenseLocalOnHeapMatrix(new double[][] {
- {4.0, -6.0, 7.0},
- {1.0, 1.0, 1.0}
- });
- System.out.println("\n>>> Matrix to solve: ");
- Tracer.showAscii(bs);
-
- Matrix sol = dec.solve(bs.transpose());
-
- System.out.println("\n>>> List of solutions: ");
- for (int i = 0; i < sol.columnSize(); i++)
- Tracer.showAscii(sol.viewColumn(i));
-
- System.out.println("\n>>> LU decomposition example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/SingularValueDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/SingularValueDecompositionExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/SingularValueDecompositionExample.java
deleted file mode 100644
index 1b2998f..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/SingularValueDecompositionExample.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 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.examples.java8.math.decompositions;
-
-import org.apache.ignite.math.Tracer;
-import org.apache.ignite.math.decompositions.SingularValueDecomposition;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-
-/**
- * Example of using {@link SingularValueDecomposition}.
- */
-public class SingularValueDecompositionExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println(">>> Singular value decomposition (SVD) example started.");
-
- // Let's compute a SVD of (l x k) matrix m. This decomposition can be thought as extension of EigenDecomposition to
- // rectangular matrices. The factorization we get is following:
- // m = u * s * v^{*}, where
- // u is a real or complex unitary matrix
- // s is a rectangular diagonal matrix with non-negative real numbers on diagonal (this numbers are singular values of m)
- // v is a real or complex unitary matrix
- // If m is real then u and v are also real.
- // Complex case is not supported for the moment.
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
- {1.0d, 0.0d, 0.0d, 0.0d, 2.0d},
- {0.0d, 0.0d, 3.0d, 0.0d, 0.0d},
- {0.0d, 0.0d, 0.0d, 0.0d, 0.0d},
- {0.0d, 2.0d, 0.0d, 0.0d, 0.0d}
- });
- System.out.println("\n>>> Matrix m for decomposition: ");
- Tracer.showAscii(m);
-
- SingularValueDecomposition dec = new SingularValueDecomposition(m);
- System.out.println("\n>>> Made decomposition m = u * s * v^{*}.");
- System.out.println(">>> Matrix u is ");
- Tracer.showAscii(dec.getU());
- System.out.println(">>> Matrix s is ");
- Tracer.showAscii(dec.getS());
- System.out.println(">>> Matrix v is ");
- Tracer.showAscii(dec.getV());
-
- // This decomposition can in particular help with solving problem of finding x minimizing 2-norm of m x such
- // that 2-norm of x is 1. It appears that it is the right singular vector corresponding to minimal singular
- // value, which is always last.
- System.out.println("\n>>> Vector x minimizing 2-norm of m x such that 2 norm of x is 1: ");
- Tracer.showAscii(dec.getV().viewColumn(dec.getSingularValues().length - 1));
-
- System.out.println("\n>>> Singular value decomposition (SVD) example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/package-info.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/package-info.java
deleted file mode 100644
index cd02b21..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/decompositions/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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. -->
- * Core algebra decomposition examples.
- */
-package org.apache.ignite.examples.java8.math.decompositions;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/CacheMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/CacheMatrixExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/CacheMatrixExample.java
deleted file mode 100644
index 44f97d2..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/CacheMatrixExample.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.Ignition;
-import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.math.IdentityValueMapper;
-import org.apache.ignite.math.MatrixKeyMapper;
-import org.apache.ignite.math.ValueMapper;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.impls.matrix.CacheMatrix;
-
-/** */
-public class CacheMatrixExample {
- /** */ private static final String CACHE_NAME = CacheMatrixExample.class.getSimpleName();
- /** */ private static final int ROWS = 3;
- /** */ private static final int COLS = 3;
-
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
- System.out.println();
- System.out.println(">>> CacheMatrix example started.");
-
- CacheConfiguration<Integer, Double> cfg = new CacheConfiguration<>();
-
- cfg.setName(CACHE_NAME);
-
- try (IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(cfg)) {
- double[][] testValues = {{1.0, 0.0, 0.0}, {1.0, 1.0, 0.0}, {1.0, 1.0, 1.0}};
-
- ValueMapper valMapper = new IdentityValueMapper();
-
- // Map matrix element indices to cache keys.
- MatrixKeyMapper<Integer> keyMapper = new MatrixKeyMapper<Integer>() {
- @Override public Integer apply(int x, int y) {
- return x * COLS + y;
- }
-
- @Override public boolean isValid(Integer integer) {
- return integer >= 0 && integer < COLS * ROWS;
- }
- };
-
- // Create cache matrix.
- CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(ROWS, COLS, cache, keyMapper, valMapper);
-
- cacheMatrix.assign(testValues);
-
- // Find all positive elements.
- Integer nonZeroes = cacheMatrix.foldMap((o, aDouble) -> {
- if (aDouble > 0)
- return o + 1;
- return o;
- }, Functions.IDENTITY, 0);
-
- assert nonZeroes.equals(6);
-
- System.out.println(">>>");
- System.out.println(">>> Finished executing Ignite \"CacheMatrix\" example.");
- System.out.println(">>> Lower triangular matrix 3x3 have only 6 positive elements.");
- System.out.println(">>>");
- }
- finally {
- // Distributed cache could be removed from cluster only by #destroyCache() call.
- ignite.destroyCache(CACHE_NAME);
- }
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/ExampleMatrixStorage.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/ExampleMatrixStorage.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/ExampleMatrixStorage.java
deleted file mode 100644
index 260f62d..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/ExampleMatrixStorage.java
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-
-import org.apache.ignite.math.MatrixStorage;
-
-/**
- * Example matrix storage, modeled after {@link org.apache.ignite.math.impls.storage.matrix.ArrayMatrixStorage}.
- */
-class ExampleMatrixStorage implements MatrixStorage {
- /** Backing data array. */
- private double[][] data;
- /** Amount of rows in a matrix storage. */
- private int rows;
- /** Amount of columns in a matrix storage. */
- private int cols;
-
- /**
- *
- */
- public ExampleMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in a matrix storage.
- * @param cols Amount of columns in a matrix storage.
- */
- ExampleMatrixStorage(int rows, int cols) {
- assert rows > 0;
- assert cols > 0;
-
- this.data = new double[rows][cols];
- this.rows = rows;
- this.cols = cols;
- }
-
- /**
- * @param data Backing data array.
- */
- ExampleMatrixStorage(double[][] data) {
- assert data != null;
- assert data[0] != null;
-
- this.data = data;
- this.rows = data.length;
- this.cols = data[0].length;
-
- assert rows > 0;
- assert cols > 0;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return data[x][y];
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- data[x][y] = v;
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public double[][] data() {
- return data;
- }
-
- /** {@inheritDoc */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
-
- out.writeObject(data);
- }
-
- /** {@inheritDoc */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
-
- data = (double[][])in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res += res * 37 + rows;
- res += res * 37 + cols;
- res += res * 37 + Arrays.deepHashCode(data);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- ExampleMatrixStorage that = (ExampleMatrixStorage)o;
-
- return Arrays.deepEquals(data, that.data);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixCustomStorageExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixCustomStorageExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixCustomStorageExample.java
deleted file mode 100644
index 637b2b4..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixCustomStorageExample.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.matrix.AbstractMatrix;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-
-/**
- * This example shows how to use {@link Matrix} API based on custom {@link MatrixStorage}.
- */
-public final class MatrixCustomStorageExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Matrix API usage example started.");
-
- System.out.println("\n>>> Creating a matrix to be transposed.");
- double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
- Matrix m = new MatrixCustomStorage(data);
- Matrix transposed = m.transpose();
-
- System.out.println(">>> Matrix: ");
- MatrixExampleUtil.print(m);
- System.out.println(">>> Transposed matrix: ");
- MatrixExampleUtil.print(transposed);
-
- MatrixExampleUtil.verifyTransposition(m, transposed);
-
- System.out.println("\n>>> Creating matrices to be multiplied.");
- double[][] data1 = new double[][] {{1, 2}, {3, 4}};
- double[][] data2 = new double[][] {{5, 6}, {7, 8}};
-
- Matrix m1 = new MatrixCustomStorage(data1);
- Matrix m2 = new MatrixCustomStorage(data2);
- Matrix mult = m1.times(m2);
-
- System.out.println(">>> First matrix: ");
- MatrixExampleUtil.print(m1);
- System.out.println(">>> Second matrix: ");
- MatrixExampleUtil.print(m2);
- System.out.println(">>> Matrix product: ");
- MatrixExampleUtil.print(mult);
-
- System.out.println("\n>>> Calculating matrices determinants.");
- double det1 = m1.determinant();
- double det2 = m2.determinant();
- double detMult = mult.determinant();
- boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
-
- System.out.println(">>> First matrix determinant: [" + det1 + "].");
- System.out.println(">>> Second matrix determinant: [" + det2 + "].");
- System.out.println(">>> Matrix product determinant: [" + detMult
- + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
-
- assert detMultIsAsExp : "Determinant of product matrix [" + detMult
- + "] should be equal to product of determinants [" + (det1 * det2) + "].";
-
- System.out.println("\n>>> Matrix API usage example completed.");
- }
-
- /**
- * Example of vector with custom storage, modeled after
- * {@link org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix}.
- */
- static class MatrixCustomStorage extends AbstractMatrix {
- /**
- *
- */
- public MatrixCustomStorage() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in a matrix.
- * @param cols Amount of columns in a matrix.
- */
- MatrixCustomStorage(int rows, int cols) {
- assert rows > 0;
- assert cols > 0;
-
- setStorage(new ExampleMatrixStorage(rows, cols));
- }
-
- /**
- * @param mtx Source matrix.
- */
- MatrixCustomStorage(double[][] mtx) {
- assert mtx != null;
-
- setStorage(new ExampleMatrixStorage(mtx));
- }
-
- /**
- * @param orig original matrix to be copied.
- */
- private MatrixCustomStorage(MatrixCustomStorage orig) {
- assert orig != null;
-
- setStorage(new ExampleMatrixStorage(orig.rowSize(), orig.columnSize()));
-
- assign(orig);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- return new MatrixCustomStorage(this);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- return new MatrixCustomStorage(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- return new DenseLocalOnHeapVector(crd);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExample.java
deleted file mode 100644
index 58cedab..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExample.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-
-/**
- * This example shows how to use {@link Matrix} API.
- */
-public final class MatrixExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Basic Matrix API usage example started.");
-
- System.out.println("\n>>> Creating a matrix to be transposed.");
- double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
- Matrix m = new DenseLocalOnHeapMatrix(data);
- Matrix transposed = m.transpose();
-
- System.out.println(">>> Matrix: ");
- MatrixExampleUtil.print(m);
- System.out.println(">>> Transposed matrix: ");
- MatrixExampleUtil.print(transposed);
-
- MatrixExampleUtil.verifyTransposition(m, transposed);
-
- System.out.println("\n>>> Creating matrices to be multiplied.");
- double[][] data1 = new double[][] {{1, 2}, {3, 4}};
- double[][] data2 = new double[][] {{5, 6}, {7, 8}};
-
- Matrix m1 = new DenseLocalOnHeapMatrix(data1);
- Matrix m2 = new DenseLocalOnHeapMatrix(data2);
- Matrix mult = m1.times(m2);
-
- System.out.println(">>> First matrix: ");
- MatrixExampleUtil.print(m1);
- System.out.println(">>> Second matrix: ");
- MatrixExampleUtil.print(m2);
- System.out.println(">>> Matrix product: ");
- MatrixExampleUtil.print(mult);
-
- System.out.println("\n>>> Calculating matrices determinants.");
- double det1 = m1.determinant();
- double det2 = m2.determinant();
- double detMult = mult.determinant();
- boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
-
- System.out.println(">>> First matrix determinant: [" + det1 + "].");
- System.out.println(">>> Second matrix determinant: [" + det2 + "].");
- System.out.println(">>> Matrix product determinant: [" + detMult
- + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
-
- assert detMultIsAsExp : "Determinant of product matrix [" + detMult
- + "] should be equal to product of determinants [" + (det1 * det2) + "].";
-
- System.out.println("\n>>> Basic Matrix API usage example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExampleUtil.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExampleUtil.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExampleUtil.java
deleted file mode 100644
index f3b4a62..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/MatrixExampleUtil.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Tracer;
-
-/**
- * Utility functions for {@link Matrix} API examples.
- */
-class MatrixExampleUtil {
- /**
- * Verifies matrix transposition.
- *
- * @param m Original matrix.
- * @param transposed Transposed matrix.
- */
- static void verifyTransposition(Matrix m, Matrix transposed) {
- for (int row = 0; row < m.rowSize(); row++)
- for (int col = 0; col < m.columnSize(); col++) {
- double val = m.get(row, col);
- double valTransposed = transposed.get(col, row);
-
- assert val == valTransposed : "Values not equal at (" + row + "," + col
- + "), original: " + val + " transposed: " + valTransposed;
- }
- }
-
- /**
- * Prints matrix values to console.
- *
- * @param m Matrix to print.
- */
- static void print(Matrix m) {
- Tracer.showAscii(m);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/OffHeapMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/OffHeapMatrixExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/OffHeapMatrixExample.java
deleted file mode 100644
index bf99da1..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/OffHeapMatrixExample.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
-
-/**
- * This example shows how to use off-heap {@link Matrix} API.
- */
-public final class OffHeapMatrixExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Off-heap matrix API usage example started.");
-
- System.out.println("\n>>> Creating a matrix to be transposed.");
- double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
- Matrix m = new DenseLocalOffHeapMatrix(data.length, data[0].length);
- m.assign(data);
- Matrix transposed = m.transpose();
-
- System.out.println(">>> Matrix: ");
- MatrixExampleUtil.print(m);
- System.out.println(">>> Transposed matrix: ");
- MatrixExampleUtil.print(transposed);
-
- MatrixExampleUtil.verifyTransposition(m, transposed);
-
- System.out.println("\n>>> Creating matrices to be multiplied.");
- double[][] data1 = new double[][] {{1, 2}, {3, 4}};
- double[][] data2 = new double[][] {{5, 6}, {7, 8}};
-
- Matrix m1 = new DenseLocalOffHeapMatrix(data1.length, data1[0].length);
- Matrix m2 = new DenseLocalOffHeapMatrix(data2.length, data2[0].length);
-
- m1.assign(data1);
- m2.assign(data2);
-
- Matrix mult = m1.times(m2);
-
- System.out.println(">>> First matrix: ");
- MatrixExampleUtil.print(m1);
- System.out.println(">>> Second matrix: ");
- MatrixExampleUtil.print(m2);
- System.out.println(">>> Matrix product: ");
- MatrixExampleUtil.print(mult);
-
- System.out.println("\n>>> Calculating matrices determinants.");
- double det1 = m1.determinant();
- double det2 = m2.determinant();
- double detMult = mult.determinant();
- boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
-
- System.out.println(">>> First matrix determinant: [" + det1 + "].");
- System.out.println(">>> Second matrix determinant: [" + det2 + "].");
- System.out.println(">>> Matrix product determinant: [" + detMult
- + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
-
- assert detMultIsAsExp : "Determinant of product matrix [" + detMult
- + "] should be equal to product of determinants [" + (det1 * det2) + "].";
-
- System.out.println("\n>>> Off-heap matrix API usage example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseDistributedMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseDistributedMatrixExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseDistributedMatrixExample.java
deleted file mode 100644
index 7e71eb0..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseDistributedMatrixExample.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.Ignite;
-import org.apache.ignite.Ignition;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.impls.matrix.SparseDistributedMatrix;
-import org.apache.ignite.thread.IgniteThread;
-
-/**
- * This example shows how to use {@link SparseDistributedMatrix} API.
- */
-public class SparseDistributedMatrixExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) throws InterruptedException {
- System.out.println();
- System.out.println(">>> Sparse distributed matrix API usage example started.");
- // Start ignite grid.
- try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
- System.out.println(">>> Ignite grid started.");
- // Create IgniteThread, we must work with SparseDistributedMatrix inside IgniteThread
- // because we create ignite cache internally.
- IgniteThread igniteThread = new IgniteThread(ignite.configuration().getIgniteInstanceName(), SparseDistributedMatrixExample.class.getSimpleName(), () -> {
-
- double[][] testValues = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}};
-
- System.out.println(">>> Create new SparseDistributedMatrix inside IgniteThread.");
- // Create SparseDistributedMatrix, new cache will be created automagically.
- SparseDistributedMatrix distributedMatrix = new SparseDistributedMatrix(testValues.length, testValues[0].length,
- StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- distributedMatrix.assign(testValues);
-
- assert distributedMatrix.sum() == 3.0;
-
- System.out.println(">>> Destroy SparseDistributedMatrix after using.");
- // Destroy internal cache.
- distributedMatrix.destroy();
- });
-
- igniteThread.start();
-
- igniteThread.join();
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseMatrixExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseMatrixExample.java
deleted file mode 100644
index ba4e72b..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/SparseMatrixExample.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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.examples.java8.math.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrix;
-
-/**
- * This example shows how to use sparse {@link Matrix} API.
- */
-public final class SparseMatrixExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Sparse matrix API usage example started.");
-
- System.out.println("\n>>> Creating a matrix to be transposed.");
- double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
- Matrix m = new SparseLocalOnHeapMatrix(data.length, data[0].length);
- m.assign(data);
- Matrix transposed = m.transpose();
-
- System.out.println(">>> Matrix: ");
- MatrixExampleUtil.print(m);
- System.out.println(">>> Transposed matrix: ");
- MatrixExampleUtil.print(transposed);
-
- MatrixExampleUtil.verifyTransposition(m, transposed);
-
- System.out.println("\n>>> Creating matrices to be multiplied.");
- double[][] data1 = new double[][] {{1, 2}, {3, 4}};
- double[][] data2 = new double[][] {{5, 6}, {7, 8}};
-
- Matrix m1 = new SparseLocalOnHeapMatrix(data1.length, data1[0].length);
- Matrix m2 = new SparseLocalOnHeapMatrix(data2.length, data2[0].length);
-
- m1.assign(data1);
- m2.assign(data2);
-
- Matrix mult = m1.times(m2);
-
- System.out.println(">>> First matrix: ");
- MatrixExampleUtil.print(m1);
- System.out.println(">>> Second matrix: ");
- MatrixExampleUtil.print(m2);
- System.out.println(">>> Matrix product: ");
- MatrixExampleUtil.print(mult);
-
- System.out.println("\n>>> Calculating matrices determinants.");
- double det1 = m1.determinant();
- double det2 = m2.determinant();
- double detMult = mult.determinant();
- boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
-
- System.out.println(">>> First matrix determinant: [" + det1 + "].");
- System.out.println(">>> Second matrix determinant: [" + det2 + "].");
- System.out.println(">>> Matrix product determinant: [" + detMult
- + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
-
- assert detMultIsAsExp : "Determinant of product matrix [" + detMult
- + "] should be equal to product of determinants [" + (det1 * det2) + "].";
-
- System.out.println("\n>>> Sparse matrix API usage example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/package-info.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/package-info.java
deleted file mode 100644
index 9154518..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/matrix/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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. -->
- * Core algebra matrix examples.
- */
-package org.apache.ignite.examples.java8.math.matrix;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/package-info.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/package-info.java
deleted file mode 100644
index 90dae33..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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. -->
- * Core algebra examples.
- */
-package org.apache.ignite.examples.java8.math;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/TracerExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/TracerExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/TracerExample.java
deleted file mode 100644
index f6e1baa..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/TracerExample.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * 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.examples.java8.math.tracer;
-
-import java.awt.Color;
-import java.io.IOException;
-import org.apache.ignite.math.Tracer;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-
-/**
- * Example of using {@link Tracer} utility API.
- */
-public class TracerExample {
- /**
- * Double to color mapper example.
- */
- private static final Tracer.ColorMapper COLOR_MAPPER = d -> {
- if (d <= 0.33)
- return Color.RED;
- else if (d <= 0.66)
- return Color.GREEN;
- else
- return Color.BLUE;
- };
-
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) throws IOException {
- System.out.println(">>> Tracer utility example started.");
-
- // Tracer is a simple utility class that allows pretty-printing of matrices/vectors
- DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
- {1.12345, 2.12345},
- {3.12345, 4.12345}
- });
-
- System.out.println("\n>>> Tracer output to console in ASCII.");
- Tracer.showAscii(m, "%.3g");
-
- System.out.println("\n>>> Tracer output to browser in HTML.");
- Tracer.showHtml(m, COLOR_MAPPER);
-
- System.out.println("\n>>> Tracer utility example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/package-info.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/package-info.java
deleted file mode 100644
index 5a08504..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/tracer/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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. -->
- * Core algebra tracer example.
- */
-package org.apache.ignite.examples.java8.math.tracer;
[11/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/Tracer.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/Tracer.java b/modules/ml/src/main/java/org/apache/ignite/math/Tracer.java
new file mode 100644
index 0000000..89d4669
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/Tracer.java
@@ -0,0 +1,456 @@
+/*
+ * 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;
+
+import java.awt.Color;
+import java.awt.Desktop;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Locale;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.apache.ignite.IgniteLogger;
+import org.apache.ignite.lang.IgniteUuid;
+
+/**
+ * Utility methods to support output of {@link Vector} and {@link Matrix} instances to plain text or HTML.
+ */
+public class Tracer {
+ /**
+ * Double to color mapper.
+ */
+ public interface ColorMapper extends Function<Double, Color> {
+ }
+
+ /** Continuous red-to-blue color mapping. */
+ static private ColorMapper defaultColorMapper(double min, double max) {
+ double range = max - min;
+
+ return new ColorMapper() {
+ /** {@inheritDoc} */
+ @Override public Color apply(Double d) {
+ int r = (int)Math.round(255 * d);
+ int g = 0;
+ int b = (int)Math.round(255 * (1 - d));
+
+ return new Color(r, g, b);
+ }
+ };
+ }
+
+ /**
+ * Default vector color mapper implementation that map given double value
+ * to continuous red-blue (R_B) specter.
+ *
+ * @param vec Vector to map.
+ * @return {@link ColorMapper} for the given vector.
+ */
+ static private ColorMapper mkVectorColorMapper(Vector vec) {
+ return defaultColorMapper(vec.minValue(), vec.maxValue());
+ }
+
+ /** Default matrix color mapper implementation that map given double value
+ * to continuous red-blue (R_B) specter.
+ * @param mtx Matrix to be mapped.
+ * @return Color mapper for given matrix.
+ */
+ static private ColorMapper mkMatrixColorMapper(Matrix mtx) {
+ return defaultColorMapper(mtx.minValue(), mtx.maxValue());
+ }
+
+ /**
+ * @param vec Vector to show.
+ * @param log {@link IgniteLogger} instance for output.
+ * @param fmt Format string for vector elements.
+ */
+ public static void showAscii(Vector vec, IgniteLogger log, String fmt) {
+ String cls = vec.getClass().getSimpleName();
+
+ log.info(String.format("%s(%d) [%s]", cls, vec.size(), mkString(vec, fmt)));
+ }
+
+ /**
+ * @param vec Vector to show as plain text.
+ * @param log {@link IgniteLogger} instance for output.
+ */
+ public static void showAscii(Vector vec, IgniteLogger log) {
+ showAscii(vec, log, "%4f");
+ }
+
+ /**
+ * @param vec Vector to show as plain text.
+ * @param fmt Format string for vector elements.
+ */
+ public static void showAscii(Vector vec, String fmt) {
+ String cls = vec.getClass().getSimpleName();
+
+ System.out.println(String.format("%s(%d) [%s]", cls, vec.size(), mkString(vec, fmt)));
+ }
+
+ /**
+ * @param mtx Matrix to show as plain text.
+ */
+ public static void showAscii(Matrix mtx) {
+ showAscii(mtx, "%4f");
+ }
+
+ /**
+ * @param mtx Matrix to show.
+ * @param row Matrix row to output.
+ * @param fmt Format string for matrix elements in the row.
+ * @return String representation of given matrix row according to given format.
+ */
+ static private String rowStr(Matrix mtx, int row, String fmt) {
+ StringBuilder buf = new StringBuilder();
+
+ boolean first = true;
+
+ int cols = mtx.columnSize();
+
+ for (int col = 0; col < cols; col++) {
+ String s = String.format(fmt, mtx.get(row, col));
+
+ if (!first)
+ buf.append(", ");
+
+ buf.append(s);
+
+ first = false;
+ }
+
+ return buf.toString();
+ }
+
+ /**
+ * @param mtx {@link Matrix} object to show as a plain text.
+ * @param fmt Format string for matrix rows.
+ */
+ public static void showAscii(Matrix mtx, String fmt) {
+ String cls = mtx.getClass().getSimpleName();
+
+ int rows = mtx.rowSize();
+ int cols = mtx.columnSize();
+
+ System.out.println(String.format("%s(%dx%d)", cls, rows, cols));
+
+ for (int row = 0; row < rows; row++)
+ System.out.println(rowStr(mtx, row, fmt));
+ }
+
+ /**
+ * @param mtx {@link Matrix} object to show as a plain text.
+ * @param log {@link IgniteLogger} instance to output the logged matrix.
+ * @param fmt Format string for matrix rows.
+ */
+ public static void showAscii(Matrix mtx, IgniteLogger log, String fmt) {
+ String cls = mtx.getClass().getSimpleName();
+
+ int rows = mtx.rowSize();
+ int cols = mtx.columnSize();
+
+ log.info(String.format("%s(%dx%d)", cls, rows, cols));
+
+ for (int row = 0; row < rows; row++)
+ log.info(rowStr(mtx, row, fmt));
+ }
+
+ /**
+ * @param vec {@link Vector} object to show as a plain text.
+ */
+ public static void showAscii(Vector vec) {
+ showAscii(vec, "%4f");
+ }
+
+ /**
+ * Saves given vector as CSV file.
+ *
+ * @param vec Vector to save.
+ * @param fmt Format to use.
+ * @param filePath Path of the file to save to.
+ */
+ public static void saveAsCsv(Vector vec, String fmt, String filePath) throws IOException {
+ String s = mkString(vec, fmt);
+
+ Files.write(Paths.get(filePath), s.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+ }
+
+ /**
+ * Saves given matrix as CSV file.
+ *
+ * @param mtx Matrix to save.
+ * @param fmt Format to use.
+ * @param filePath Path of the file to save to.
+ */
+ public static void saveAsCsv(Matrix mtx, String fmt, String filePath) throws IOException {
+ String s = mkString(mtx, fmt);
+
+ Files.write(Paths.get(filePath), s.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
+ }
+
+ /**
+ * Shows given matrix in the browser with D3-based visualization.
+ *
+ * @param mtx Matrix to show.
+ * @throws IOException Thrown in case of any errors.
+ */
+ public static void showHtml(Matrix mtx) throws IOException {
+ showHtml(mtx, mkMatrixColorMapper(mtx));
+ }
+
+ /**
+ * Shows given matrix in the browser with D3-based visualization.
+ *
+ * @param mtx Matrix to show.
+ * @param cm Optional color mapper. If not provided - red-to-blue (R_B) mapper will be used.
+ * @throws IOException Thrown in case of any errors.
+ */
+ public static void showHtml(Matrix mtx, ColorMapper cm) throws IOException {
+ // Read it every time so that we can change it at runtime.
+ String tmpl = fileToString("d3-matrix-template.html");
+
+ String cls = mtx.getClass().getSimpleName();
+
+ double min = mtx.minValue();
+ double max = mtx.maxValue();
+
+ openHtmlFile(tmpl.
+ replaceAll("/\\*@NAME@\\*/.*\n", "var name = \"" + cls + "\";\n").
+ replaceAll("/\\*@MIN@\\*/.*\n", "var min = " + dataColorJson(min, cm.apply(min)) + ";\n").
+ replaceAll("/\\*@MAX@\\*/.*\n", "var max = " + dataColorJson(max, cm.apply(max)) + ";\n").
+ replaceAll("/\\*@DATA@\\*/.*\n", "var data = " + mkJsArrayString(mtx, cm) + ";\n")
+ );
+ }
+
+ /**
+ * Shows given vector in the browser with D3-based visualization.
+ *
+ * @param vec Vector to show.
+ * @throws IOException Thrown in case of any errors.
+ */
+ public static void showHtml(Vector vec) throws IOException {
+ showHtml(vec, mkVectorColorMapper(vec));
+ }
+
+ /**
+ * @param d Value of {@link Matrix} or {@link Vector} element.
+ * @param clr {@link Color} to paint.
+ * @return JSON representation for given value and color.
+ */
+ static private String dataColorJson(double d, Color clr) {
+ return "{" +
+ "d: " + String.format("%4f", d) +
+ ", r: " + clr.getRed() +
+ ", g: " + clr.getGreen() +
+ ", b: " + clr.getBlue() +
+ "}";
+ }
+
+ /**
+ * Shows given vector in the browser with D3-based visualization.
+ *
+ * @param vec Vector to show.
+ * @param cm Optional color mapper. If not provided - red-to-blue (R_B) mapper will be used.
+ * @throws IOException Thrown in case of any errors.
+ */
+ public static void showHtml(Vector vec, ColorMapper cm) throws IOException {
+ // Read it every time so that we can change it at runtime.
+ String tmpl = fileToString("d3-vector-template.html");
+
+ String cls = vec.getClass().getSimpleName();
+
+ double min = vec.minValue();
+ double max = vec.maxValue();
+
+ openHtmlFile(tmpl.
+ replaceAll("/\\*@NAME@\\*/.*\n", "var name = \"" + cls + "\";\n").
+ replaceAll("/\\*@MIN@\\*/.*\n", "var min = " + dataColorJson(min, cm.apply(min)) + ";\n").
+ replaceAll("/\\*@MAX@\\*/.*\n", "var max = " + dataColorJson(max, cm.apply(max)) + ";\n").
+ replaceAll("/\\*@DATA@\\*/.*\n", "var data = " + mkJsArrayString(vec, cm) + ";\n")
+ );
+ }
+
+ /**
+ * Reads file content into the string.
+ *
+ * @param fileName Name of the file (on classpath) to read.
+ * @return Content of the file.
+ * @throws IOException If an I/O error of some sort has occurred.
+ */
+ private static String fileToString(String fileName) throws IOException {
+ assert Tracer.class.getResourceAsStream(fileName) != null : "Can't get resource: " + fileName;
+
+ InputStreamReader is = new InputStreamReader(Tracer.class.getResourceAsStream(fileName));
+
+ String str = new BufferedReader(is).lines().collect(Collectors.joining("\n"));
+
+ is.close();
+
+ return str;
+ }
+
+ /**
+ * Opens file in the browser with given HTML content.
+ *
+ * @param html HTML content.
+ * @throws IOException Thrown in case of any errors.
+ */
+ static private void openHtmlFile(String html) throws IOException {
+ File temp = File.createTempFile(IgniteUuid.randomUuid().toString(), ".html");
+
+ BufferedWriter bw = new BufferedWriter(new FileWriter(temp));
+
+ bw.write(html);
+
+ bw.close();
+
+ Desktop.getDesktop().browse(temp.toURI());
+ }
+
+ /**
+ * Gets string presentation of this vector.
+ *
+ * @param vec Vector to string-ify.
+ * @param fmt {@link String#format(Locale, String, Object...)} format.
+ */
+ private static String mkString(Vector vec, String fmt) {
+ boolean first = true;
+
+ StringBuilder buf = new StringBuilder();
+
+ for (Vector.Element x : vec.all()) {
+ String s = String.format(Locale.US, fmt, x.get());
+
+ if (!first) {
+ buf.append(", ");
+ buf.append(s);
+ }
+ else {
+ buf.append(s);
+ first = false;
+ }
+ }
+
+ return buf.toString();
+ }
+
+ /**
+ * Gets JavaScript array presentation of this vector.
+ *
+ * @param vec Vector to JavaScript-ify.
+ * @param cm Color mapper to user.
+ */
+ private static String mkJsArrayString(Vector vec, ColorMapper cm) {
+ boolean first = true;
+
+ StringBuilder buf = new StringBuilder();
+
+ for (Vector.Element x : vec.all()) {
+ double d = x.get();
+
+ String s = dataColorJson(d, cm.apply(d));
+
+ if (!first)
+ buf.append(", ");
+
+ buf.append(s);
+
+ first = false;
+ }
+
+ return '[' + buf.toString() + ']';
+ }
+
+ /**
+ * Gets JavaScript array presentation of this vector.
+ *
+ * @param mtx Matrix to JavaScript-ify.
+ * @param cm Color mapper to user.
+ */
+ private static String mkJsArrayString(Matrix mtx, ColorMapper cm) {
+ boolean first = true;
+
+ StringBuilder buf = new StringBuilder();
+
+ int rows = mtx.rowSize();
+ int cols = mtx.columnSize();
+
+ for (int row = 0; row < rows; row++) {
+ StringBuilder rowBuf = new StringBuilder();
+
+ boolean rowFirst = true;
+
+ for (int col = 0; col < cols; col++) {
+ double d = mtx.get(row, col);
+
+ String s = dataColorJson(d, cm.apply(d));
+
+ if (!rowFirst)
+ rowBuf.append(", ");
+
+ rowBuf.append(s);
+
+ rowFirst = false;
+ }
+
+ if (!first)
+ buf.append(", ");
+
+ buf.append('[').append(rowBuf.toString()).append(']');
+
+ first = false;
+ }
+
+ return '[' + buf.toString() + ']';
+ }
+
+ /**
+ * @param mtx Matrix to log.
+ * @param fmt Output format.
+ * @return Formatted representation of a matrix.
+ */
+ private static String mkString(Matrix mtx, String fmt) {
+ StringBuilder buf = new StringBuilder();
+
+ int rows = mtx.rowSize();
+ int cols = mtx.columnSize();
+
+ for (int row = 0; row < rows; row++) {
+ for (int col = 0; col < cols; col++) {
+ String s = String.format(Locale.US, fmt, mtx.get(row, col));
+
+ if (col != 0)
+ buf.append(", ");
+
+ buf.append(s);
+
+ if (col == cols - 1 && row != rows - 1)
+ buf.append(",\n");
+
+ }
+ }
+
+ return buf.toString();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/ValueMapper.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/ValueMapper.java b/modules/ml/src/main/java/org/apache/ignite/math/ValueMapper.java
new file mode 100644
index 0000000..9459bd1
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/ValueMapper.java
@@ -0,0 +1,27 @@
+// @java.file.header
+
+/* _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+package org.apache.ignite.math;
+
+import java.io.Serializable;
+
+/**
+ * Utility mapper that can be used to map arbitrary values types to and from double.
+ */
+public interface ValueMapper<V> extends Serializable {
+ /**
+ * @param v
+ */
+ public V fromDouble(double v);
+
+ /**
+ * @param v
+ */
+ public double toDouble(V v);
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/Vector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/Vector.java b/modules/ml/src/main/java/org/apache/ignite/math/Vector.java
new file mode 100644
index 0000000..ac2a6c7
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/Vector.java
@@ -0,0 +1,498 @@
+/*
+ * 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;
+
+import java.io.Externalizable;
+import java.util.Spliterator;
+import java.util.function.IntToDoubleFunction;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+
+/**
+ * A vector interface.
+ *
+ * Based on its flavor it can have vastly different implementations tailored for
+ * for different types of data (e.g. dense vs. sparse), different sizes of data or different operation
+ * optimizations.
+ *
+ * Note also that not all operations can be supported by all underlying implementations. If an operation is not
+ * supported a {@link UnsupportedOperationException} is thrown. This exception can also be thrown in partial cases
+ * where an operation is unsupported only in special cases, e.g. where a given operation cannot be deterministically
+ * completed in polynomial time.
+ *
+ * Based on ideas from <a href="http://mahout.apache.org/">Apache Mahout</a>.
+ */
+public interface Vector extends MetaAttributes, Externalizable, StorageOpsMetrics, Destroyable {
+ /**
+ * Holder for vector's element.
+ */
+ interface Element {
+ /**
+ * Gets element's value.
+ *
+ * @return The value of this vector element.
+ */
+ double get();
+
+ /**
+ * Gets element's index in the vector.
+ *
+ * @return The index of this vector element.
+ */
+ int index();
+
+ /**
+ * Sets element's value.
+ *
+ * @param val Value to set.
+ */
+ void set(double val);
+ }
+
+ /**
+ * Gets cardinality of this vector (maximum number of the elements).
+ *
+ * @return This vector's cardinality.
+ */
+ public int size();
+
+ /**
+ * Creates new copy of this vector.
+ *
+ * @return New copy vector.
+ */
+ public Vector copy();
+
+ /**
+ * Gets iterator over all elements in this vector.
+ *
+ * NOTE: implementation can choose to reuse {@link Element} instance so you need to copy it
+ * if you want to retain it outside of iteration.
+ *
+ * @return Iterator.
+ */
+ public Iterable<Element> all();
+
+ /**
+ * Iterates ove all non-zero elements in this vector.
+ *
+ * NOTE: implementation can choose to reuse {@link Element} instance so you need to copy it
+ * if you want to retain it outside of iteration.
+ *
+ * @return Iterator.
+ */
+ public Iterable<Element> nonZeroes();
+
+ /**
+ * Gets spliterator for all values in this vector.
+ *
+ * @return Spliterator for all values.
+ */
+ public Spliterator<Double> allSpliterator();
+
+ /**
+ * Gets spliterator for all non-zero values in this vector.
+ *
+ * @return Spliterator for all non-zero values.
+ */
+ public Spliterator<Double> nonZeroSpliterator();
+
+ /**
+ * Sorts this vector in ascending order.
+ */
+ public Vector sort();
+
+ /**
+ * Gets element at the given index.
+ *
+ * NOTE: implementation can choose to reuse {@link Element} instance so you need to copy it
+ * if you want to retain it outside of iteration.
+ *
+ * @param idx Element's index.
+ * @return Vector's element at the given index.
+ * @throws IndexException Throw if index is out of bounds.
+ */
+ public Element getElement(int idx);
+
+ /**
+ * Assigns given value to all elements of this vector.
+ *
+ * @param val Value to assign.
+ * @return This vector.
+ */
+ public Vector assign(double val);
+
+ /**
+ * Assigns values from given array to this vector.
+ *
+ * @param vals Values to assign.
+ * @return This vector.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector assign(double[] vals);
+
+ /**
+ * Copies values from the argument vector to this one.
+ *
+ * @param vec Argument vector.
+ * @return This vector.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector assign(Vector vec);
+
+ /**
+ * Assigns each vector element to the value generated by given function.
+ *
+ * @param fun Function that takes the index and returns value.
+ * @return This vector.
+ */
+ public Vector assign(IntToDoubleFunction fun);
+
+ /**
+ * Maps all values in this vector through a given function.
+ *
+ * @param fun Mapping function.
+ * @return This vector.
+ */
+ public Vector map(IgniteDoubleFunction<Double> fun);
+
+ /**
+ * Maps all values in this vector through a given function.
+ *
+ * For this vector <code>A</code>, argument vector <code>B</code> and the
+ * function <code>F</code> this method maps every element <code>x</code> as:
+ * <code>A(x) = F(A(x), B(x))</code>
+ *
+ * @param vec Argument vector.
+ * @param fun Mapping function.
+ * @return This function.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun);
+
+ /**
+ * Maps all elements of this vector by applying given function to each element with a constant
+ * second parameter <code>y</code>.
+ *
+ * @param fun Mapping function.
+ * @param y Second parameter for mapping function.
+ * @return This vector.
+ */
+ public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y);
+
+ /**
+ * Creates new vector containing values from this vector divided by the argument.
+ *
+ * @param x Division argument.
+ * @return New vector.
+ */
+ public Vector divide(double x);
+
+ /**
+ * Gets dot product of two vectors.
+ *
+ * @param vec Argument vector.
+ * @return Dot product of two vectors.
+ */
+ public double dot(Vector vec);
+
+ /**
+ * Gets the value at specified index.
+ *
+ * @param idx Vector index.
+ * @return Vector value.
+ * @throws IndexException Throw if index is out of bounds.
+ */
+ public double get(int idx);
+
+ /**
+ * Gets the value at specified index without checking for index boundaries.
+ *
+ * @param idx Vector index.
+ * @return Vector value.
+ */
+ public double getX(int idx);
+
+ /**
+ * Creates new empty vector of the same underlying class but of different cardinality.
+ *
+ * @param crd Cardinality for new vector.
+ * @return New vector.
+ */
+ public Vector like(int crd);
+
+ /**
+ * Creates new matrix of compatible flavor with given size.
+ *
+ * @param rows Number of rows.
+ * @param cols Number of columns.
+ * @return New matrix.
+ */
+ public Matrix likeMatrix(int rows, int cols);
+
+ /**
+ * Converts this vector into [N x 1] or [1 x N] matrix where N is this vector cardinality.
+ *
+ * @param rowLike {@code true} for rowLike [N x 1], or {@code false} for column [1 x N] matrix.
+ * @return Newly created matrix.
+ */
+ public Matrix toMatrix(boolean rowLike);
+
+ /**
+ * Converts this vector into [N+1 x 1] or [1 x N+1] matrix where N is this vector cardinality.
+ * (0,0) element of this matrix will be {@code zeroVal} parameter.
+ *
+ * @param rowLike {@code true} for rowLike [N+1 x 1], or {@code false} for column [1 x N+1] matrix.
+ * @return Newly created matrix.
+ */
+ public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal);
+
+ /**
+ * Creates new vector containing element by element difference between this vector and the argument one.
+ *
+ * @param vec Argument vector.
+ * @return New vector.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector minus(Vector vec);
+
+ /**
+ * Creates new vector containing the normalized (L_2 norm) values of this vector.
+ *
+ * @return New vector.
+ */
+ public Vector normalize();
+
+ /**
+ * Creates new vector containing the normalized (L_power norm) values of this vector.
+ * See http://en.wikipedia.org/wiki/Lp_space for details.
+ *
+ * @param power The power to use. Must be >= 0. May also be {@link Double#POSITIVE_INFINITY}.
+ * @return New vector {@code x} such that {@code norm(x, power) == 1}
+ */
+ public Vector normalize(double power);
+
+ /**
+ * Creates new vector containing the {@code log(1 + entry) / L_2 norm} values of this vector.
+ *
+ * @return New vector.
+ */
+ public Vector logNormalize();
+
+ /**
+ * Creates new vector with a normalized value calculated as {@code log_power(1 + entry) / L_power norm}.
+ *
+ * @param power The power to use. Must be > 1. Cannot be {@link Double#POSITIVE_INFINITY}.
+ * @return New vector
+ */
+ public Vector logNormalize(double power);
+
+ /**
+ * Gets the k-norm of the vector. See http://en.wikipedia.org/wiki/Lp_space for more details.
+ *
+ * @param power The power to use.
+ * @see #normalize(double)
+ */
+ public double kNorm(double power);
+
+ /**
+ * Gets minimal value in this vector.
+ *
+ * @return Minimal value.
+ */
+ public double minValue();
+
+ /**
+ * Gets maximum value in this vector.
+ *
+ * @return Maximum c.
+ */
+ public double maxValue();
+
+ /**
+ * Gets minimal element in this vector.
+ *
+ * @return Minimal element.
+ */
+ public Element minElement();
+
+ /**
+ * Gets maximum element in this vector.
+ *
+ * @return Maximum element.
+ */
+ public Element maxElement();
+
+ /**
+ * Creates new vector containing sum of each element in this vector and argument.
+ *
+ * @param x Argument value.
+ * @return New vector.
+ */
+ public Vector plus(double x);
+
+ /**
+ * Creates new vector containing element by element sum from both vectors.
+ *
+ * @param vec Other argument vector to add.
+ * @return New vector.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector plus(Vector vec);
+
+ /**
+ * Sets value.
+ *
+ * @param idx Vector index to set value at.
+ * @param val Value to set.
+ * @return This vector.
+ * @throws IndexException Throw if index is out of bounds.
+ */
+ public Vector set(int idx, double val);
+
+ /**
+ * Sets value without checking for index boundaries.
+ *
+ * @param idx Vector index to set value at.
+ * @param val Value to set.
+ * @return This vector.
+ */
+ public Vector setX(int idx, double val);
+
+ /**
+ * Increments value at given index without checking for index boundaries.
+ *
+ * @param idx Vector index.
+ * @param val Increment value.
+ * @return This vector.
+ */
+ public Vector incrementX(int idx, double val);
+
+ /**
+ * Increments value at given index.
+ *
+ * @param idx Vector index.
+ * @param val Increment value.
+ * @return This vector.
+ * @throws IndexException Throw if index is out of bounds.
+ */
+ public Vector increment(int idx, double val);
+
+ /**
+ * Gets number of non-zero elements in this vector.
+ *
+ * @return Number of non-zero elements in this vector.
+ */
+ public int nonZeroElements();
+
+ /**
+ * Gets a new vector that contains product of each element and the argument.
+ *
+ * @param x Multiply argument.
+ * @return New vector.
+ */
+ public Vector times(double x);
+
+ /**
+ * Gets a new vector that is an element-wie product of this vector and the argument.
+ *
+ * @param vec Vector to multiply by.
+ * @return New vector.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public Vector times(Vector vec);
+
+ /**
+ * @param off Offset into parent vector.
+ * @param len Length of the view.
+ */
+ public Vector viewPart(int off, int len);
+
+ /**
+ * Gets vector storage model.
+ */
+ public VectorStorage getStorage();
+
+ /**
+ * Gets the sum of all elements in this vector.
+ *
+ * @return Vector's sum
+ */
+ public double sum();
+
+ /**
+ * Gets the cross product of this vector and the other vector.
+ *
+ * @param vec Second vector.
+ * @return New matrix as a cross product of two vectors.
+ */
+ public Matrix cross(Vector vec);
+
+ /**
+ * Folds this vector into a single value.
+ *
+ * @param foldFun Folding function that takes two parameters: accumulator and the current value.
+ * @param mapFun Mapping function that is called on each vector element before its passed to the accumulator (as its
+ * second parameter).
+ * @param <T> Type of the folded value.
+ * @param zeroVal Zero value for fold operation.
+ * @return Folded value of this vector.
+ */
+ public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun, T zeroVal);
+
+ /**
+ * Combines & maps two vector and folds them into a single value.
+ *
+ * @param vec Another vector to combine with.
+ * @param foldFun Folding function.
+ * @param combFun Combine function.
+ * @param <T> Type of the folded value.
+ * @param zeroVal Zero value for fold operation.
+ * @return Folded value of these vectors.
+ * @throws CardinalityException Thrown when cardinalities mismatch.
+ */
+ public <T> T foldMap(Vector vec, IgniteBiFunction<T, Double, T> foldFun, IgniteBiFunction<Double, Double, Double> combFun,
+ T zeroVal);
+
+ /**
+ * Gets the sum of squares of all elements in this vector.
+ *
+ * @return Length squared value.
+ */
+ public double getLengthSquared();
+
+ /**
+ * Get the square of the distance between this vector and the argument vector.
+ *
+ * @param vec Another vector.
+ * @return Distance squared.
+ * @throws CardinalityException Thrown if cardinalities mismatch.
+ */
+ public double getDistanceSquared(Vector vec);
+
+ /**
+ * Auto-generated globally unique vector ID.
+ *
+ * @return Vector GUID.
+ */
+ public IgniteUuid guid();
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/VectorKeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/VectorKeyMapper.java b/modules/ml/src/main/java/org/apache/ignite/math/VectorKeyMapper.java
new file mode 100644
index 0000000..17d76f5
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/VectorKeyMapper.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;
+
+/**
+ * Maps {@link Vector} element index to cache key.
+ */
+public interface VectorKeyMapper<K> extends KeyMapper<K> {
+ /**
+ * @param i Vector element index.
+ * @return Cache key for given element index.
+ */
+ public K apply(int i);
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/VectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/VectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/VectorStorage.java
new file mode 100644
index 0000000..f410254
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/VectorStorage.java
@@ -0,0 +1,53 @@
+/*
+ * 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;
+
+import java.io.Externalizable;
+
+/**
+ * Data storage support for {@link Vector}.
+ */
+public interface VectorStorage extends Externalizable, StorageOpsMetrics, Destroyable {
+ /**
+ *
+ *
+ */
+ public int size();
+
+ /**
+ * @param i Vector element index.
+ * @return Value obtained for given element index.
+ */
+ public double get(int i);
+
+ /**
+ * @param i Vector element index.
+ * @param v Value to set at given index.
+ */
+ public void set(int i, double v);
+
+ /**
+ * Gets underlying array if {@link StorageOpsMetrics#isArrayBased()} returns {@code true}.
+ * Returns {@code null} if in other cases.
+ *
+ * @see StorageOpsMetrics#isArrayBased()
+ */
+ public default double[] data() {
+ return null;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java
new file mode 100644
index 0000000..9554737
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java
@@ -0,0 +1,306 @@
+/*
+ * 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.NonPositiveDefiniteMatrixException;
+import org.apache.ignite.math.exceptions.NonSymmetricMatrixException;
+
+/**
+ * Calculates the Cholesky decomposition of a matrix.
+ *
+ * This class inspired by class from Apache Common Math with similar name.
+ *
+ * @see <a href="http://mathworld.wolfram.com/CholeskyDecomposition.html">MathWorld</a>
+ * @see <a href="http://en.wikipedia.org/wiki/Cholesky_decomposition">Wikipedia</a>
+ */
+public class CholeskyDecomposition extends DecompositionSupport {
+ /**
+ * Default threshold above which off-diagonal elements are considered too different
+ * and matrix not symmetric.
+ */
+ public static final double DFLT_REL_SYMMETRY_THRESHOLD = 1.0e-15;
+
+ /**
+ * Default threshold below which diagonal elements are considered null
+ * and matrix not positive definite.
+ */
+ public static final double DFLT_ABS_POSITIVITY_THRESHOLD = 1.0e-10;
+
+ /** Row-oriented storage for L<sup>T</sup> matrix data. */
+ private double[][] lTData;
+ /** Cached value of L. */
+ private Matrix cachedL;
+ /** Cached value of LT. */
+ private Matrix cachedLT;
+ /** Origin matrix */
+ private Matrix origin;
+
+ /**
+ * Calculates the Cholesky decomposition of the given matrix.
+ *
+ * Calling this constructor is equivalent to call {@link #CholeskyDecomposition(Matrix, double, double)} with the
+ * thresholds set to the default values {@link #DFLT_REL_SYMMETRY_THRESHOLD} and
+ * {@link #DFLT_ABS_POSITIVITY_THRESHOLD}.
+ *
+ * @param mtx the matrix to decompose.
+ * @throws CardinalityException if matrix is not square.
+ * @see #CholeskyDecomposition(Matrix, double, double)
+ * @see #DFLT_REL_SYMMETRY_THRESHOLD
+ * @see #DFLT_ABS_POSITIVITY_THRESHOLD
+ */
+ public CholeskyDecomposition(final Matrix mtx) {
+ this(mtx, DFLT_REL_SYMMETRY_THRESHOLD, DFLT_ABS_POSITIVITY_THRESHOLD);
+ }
+
+ /**
+ * Calculates the Cholesky decomposition of the given matrix.
+ *
+ * @param mtx the matrix to decompose.
+ * @param relSymmetryThreshold threshold above which off-diagonal elements are considered too different and matrix
+ * not symmetric
+ * @param absPositivityThreshold threshold below which diagonal elements are considered null and matrix not positive
+ * definite
+ * @see #CholeskyDecomposition(Matrix)
+ * @see #DFLT_REL_SYMMETRY_THRESHOLD
+ * @see #DFLT_ABS_POSITIVITY_THRESHOLD
+ */
+ public CholeskyDecomposition(final Matrix mtx, final double relSymmetryThreshold,
+ final double absPositivityThreshold) {
+ assert mtx != null;
+
+ if (mtx.columnSize() != mtx.rowSize())
+ throw new CardinalityException(mtx.rowSize(), mtx.columnSize());
+
+ origin = mtx;
+
+ final int order = mtx.rowSize();
+
+ lTData = toDoubleArr(mtx);
+ cachedL = null;
+ cachedLT = null;
+
+ // Check the matrix before transformation.
+ for (int i = 0; i < order; ++i) {
+ final double[] lI = lTData[i];
+
+ // Check off-diagonal elements (and reset them to 0).
+ for (int j = i + 1; j < order; ++j) {
+ final double[] lJ = lTData[j];
+
+ final double lIJ = lI[j];
+ final double lJI = lJ[i];
+
+ final double maxDelta = relSymmetryThreshold * Math.max(Math.abs(lIJ), Math.abs(lJI));
+
+ if (Math.abs(lIJ - lJI) > maxDelta)
+ throw new NonSymmetricMatrixException(i, j, relSymmetryThreshold);
+
+ lJ[i] = 0;
+ }
+ }
+
+ // Transform the matrix.
+ for (int i = 0; i < order; ++i) {
+ final double[] ltI = lTData[i];
+
+ // Check diagonal element.
+ if (ltI[i] <= absPositivityThreshold)
+ throw new NonPositiveDefiniteMatrixException(ltI[i], i, absPositivityThreshold);
+
+ ltI[i] = Math.sqrt(ltI[i]);
+ final double inverse = 1.0 / ltI[i];
+
+ for (int q = order - 1; q > i; --q) {
+ ltI[q] *= inverse;
+ final double[] ltQ = lTData[q];
+
+ for (int p = q; p < order; ++p)
+ ltQ[p] -= ltI[q] * ltI[p];
+ }
+ }
+ }
+
+ /** */
+ @Override public void destroy() {
+ if (cachedL != null)
+ cachedL.destroy();
+ if (cachedLT != null)
+ cachedLT.destroy();
+ }
+
+ /**
+ * Returns the matrix L of the decomposition.
+ * <p>L is an lower-triangular matrix</p>
+ *
+ * @return the L matrix
+ */
+ public Matrix getL() {
+ if (cachedL == null)
+ cachedL = getLT().transpose();
+
+ return cachedL;
+ }
+
+ /**
+ * Returns the transpose of the matrix L of the decomposition.
+ * <p>L<sup>T</sup> is an upper-triangular matrix</p>
+ *
+ * @return the transpose of the matrix L of the decomposition
+ */
+ public Matrix getLT() {
+
+ if (cachedLT == null) {
+ Matrix like = like(origin, origin.rowSize(), origin.columnSize());
+ like.assign(lTData);
+
+ cachedLT = like;
+ }
+
+ // return the cached matrix
+ return cachedLT;
+ }
+
+ /**
+ * Return the determinant of the matrix
+ *
+ * @return determinant of the matrix
+ */
+ public double getDeterminant() {
+ double determinant = 1.0;
+
+ for (int i = 0; i < lTData.length; ++i) {
+ double lTii = lTData[i][i];
+ determinant *= lTii * lTii;
+ }
+
+ return determinant;
+ }
+
+ /**
+ * Solve the linear equation A × X = B for matrices A.
+ *
+ * @param b right-hand side of the equation A × X = B
+ * @return a vector X that minimizes the two norm of A × X - B
+ * @throws CardinalityException if the vectors dimensions do not match
+ */
+ public Vector solve(final Vector b) {
+ final int m = lTData.length;
+
+ if (b.size() != m)
+ throw new CardinalityException(b.size(), m);
+
+ final double[] x = b.getStorage().data();
+
+ // Solve LY = b
+ for (int j = 0; j < m; j++) {
+ final double[] lJ = lTData[j];
+
+ x[j] /= lJ[j];
+
+ final double xJ = x[j];
+
+ for (int i = j + 1; i < m; i++)
+ x[i] -= xJ * lJ[i];
+ }
+
+ // Solve LTX = Y
+ for (int j = m - 1; j >= 0; j--) {
+ x[j] /= lTData[j][j];
+
+ final double xJ = x[j];
+
+ for (int i = 0; i < j; i++)
+ x[i] -= xJ * lTData[i][j];
+ }
+
+ return likeVector(origin, m).assign(x);
+ }
+
+ /**
+ * Solve the linear equation A × X = B for matrices A.
+ *
+ * @param b right-hand side of the equation A × X = B
+ * @return a matrix X that minimizes the two norm of A × X - B
+ * @throws CardinalityException if the matrices dimensions do not match
+ */
+ public Matrix solve(final Matrix b) {
+ final int m = lTData.length;
+
+ if (b.rowSize() != m)
+ throw new CardinalityException(b.rowSize(), m);
+
+ final int nColB = b.columnSize();
+ final double[][] x = b.getStorage().data();
+
+ // Solve LY = b
+ for (int j = 0; j < m; j++) {
+ final double[] lJ = lTData[j];
+ final double lJJ = lJ[j];
+ final double[] xJ = x[j];
+
+ for (int k = 0; k < nColB; ++k)
+ xJ[k] /= lJJ;
+
+ for (int i = j + 1; i < m; i++) {
+ final double[] xI = x[i];
+ final double lJI = lJ[i];
+
+ for (int k = 0; k < nColB; ++k)
+ xI[k] -= xJ[k] * lJI;
+ }
+ }
+
+ // Solve LTX = Y
+ for (int j = m - 1; j >= 0; j--) {
+ final double lJJ = lTData[j][j];
+ final double[] xJ = x[j];
+
+ for (int k = 0; k < nColB; ++k)
+ xJ[k] /= lJJ;
+
+ for (int i = 0; i < j; i++) {
+ final double[] xI = x[i];
+ final double lIJ = lTData[i][j];
+
+ for (int k = 0; k < nColB; ++k)
+ xI[k] -= xJ[k] * lIJ;
+ }
+ }
+
+ return like(origin, m, b.columnSize()).assign(x);
+ }
+
+ /** */
+ private double[][] toDoubleArr(Matrix mtx) {
+ if (mtx.isArrayBased())
+ return mtx.getStorage().data();
+
+ double[][] res = new double[mtx.rowSize()][];
+
+ for (int row = 0; row < mtx.rowSize(); row++) {
+ res[row] = new double[mtx.columnSize()];
+ for (int col = 0; col < mtx.columnSize(); col++)
+ res[row][col] = mtx.get(row, col);
+ }
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java
new file mode 100644
index 0000000..2c76284
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/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.math.decompositions;
+
+import org.apache.ignite.math.Destroyable;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.matrix.CacheMatrix;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
+import org.apache.ignite.math.impls.matrix.RandomMatrix;
+import org.apache.ignite.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/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java b/modules/ml/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java
new file mode 100644
index 0000000..66fe13c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/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.math.decompositions;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.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;
+ }
+ }
+}
[24/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/CacheVectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/CacheVectorExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/CacheVectorExample.java
new file mode 100644
index 0000000..3e83ef5
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/CacheVectorExample.java
@@ -0,0 +1,102 @@
+/*
+ * 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.examples.ml.math.vector;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.math.IdentityValueMapper;
+import org.apache.ignite.math.ValueMapper;
+import org.apache.ignite.math.VectorKeyMapper;
+import org.apache.ignite.math.impls.vector.CacheVector;
+
+/**
+ * This example shows how to use {@link CacheVector} API.
+ */
+public class CacheVectorExample {
+ /** */ private static final String CACHE_NAME = CacheVectorExample.class.getSimpleName();
+ /** */ private static final int CARDINALITY = 10;
+
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
+ System.out.println();
+ System.out.println(">>> CacheVector example started.");
+
+ CacheConfiguration<Integer, Double> cfg = new CacheConfiguration<>();
+
+ cfg.setName(CACHE_NAME);
+
+ try (IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(cfg)) {
+ double[] testValues1 = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+ double[] testValues2 = {0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+
+ ValueMapper valMapper = new IdentityValueMapper();
+
+ // Map vector element index to cache keys.
+ VectorKeyMapper<Integer> keyMapper1 = new VectorKeyMapper<Integer>() {
+ @Override public Integer apply(int i) {
+ return i;
+ }
+
+ @Override public boolean isValid(Integer integer) {
+ return integer >= 0 && CARDINALITY > integer;
+ }
+ };
+
+ // Map vector element index to cache keys with shift.
+ VectorKeyMapper<Integer> keyMapper2 = new VectorKeyMapper<Integer>() {
+ @Override public Integer apply(int i) {
+ return i + CARDINALITY;
+ }
+
+ @Override public boolean isValid(Integer integer) {
+ return integer >= 0 && CARDINALITY > integer;
+ }
+ };
+
+ // Create two cache vectors over one cache.
+ CacheVector cacheVector1 = new CacheVector(CARDINALITY, cache, keyMapper1, valMapper);
+ System.out.println(">>> First cache vector created.");
+
+ CacheVector cacheVector2 = new CacheVector(CARDINALITY, cache, keyMapper2, valMapper);
+ System.out.println(">>> Second cache vector created.");
+
+ cacheVector1.assign(testValues1);
+ cacheVector2.assign(testValues2);
+
+ // Dot product for orthogonal vectors is 0.0.
+ assert cacheVector1.dot(cacheVector2) == 0.0;
+
+ System.out.println(">>>");
+ System.out.println(">>> Finished executing Ignite \"CacheVector\" example.");
+ System.out.println(">>> Dot product is 0.0 for orthogonal vectors.");
+ System.out.println(">>>");
+ }
+ finally {
+ // Distributed cache could be removed from cluster only by #destroyCache() call.
+ ignite.destroyCache(CACHE_NAME);
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/ExampleVectorStorage.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/ExampleVectorStorage.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/ExampleVectorStorage.java
new file mode 100644
index 0000000..b382c46
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/ExampleVectorStorage.java
@@ -0,0 +1,126 @@
+/*
+ * 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.examples.ml.math.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * Example vector storage, modeled after {@link org.apache.ignite.math.impls.storage.vector.ArrayVectorStorage}.
+ */
+class ExampleVectorStorage implements VectorStorage {
+ /** */
+ private double[] data;
+
+ /**
+ * IMPL NOTE required by Externalizable
+ */
+ public ExampleVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param data backing data array.
+ */
+ ExampleVectorStorage(double[] data) {
+ assert data != null;
+
+ this.data = data;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return data == null ? 0 : data.length;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return data[i];
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ data[i] = v;
+ }
+
+ /** {@inheritDoc}} */
+ @Override public boolean isArrayBased() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[] data() {
+ return data;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(data);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ data = (double[])in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + Arrays.hashCode(data);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ ExampleVectorStorage that = (ExampleVectorStorage)obj;
+
+ return Arrays.equals(data, (that.data));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/OffHeapVectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/OffHeapVectorExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/OffHeapVectorExample.java
new file mode 100644
index 0000000..031843b
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/OffHeapVectorExample.java
@@ -0,0 +1,78 @@
+/*
+ * 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.examples.ml.math.vector;
+
+import java.util.Arrays;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
+
+/**
+ * This example shows how to use off-heap {@link Vector} API.
+ */
+public final class OffHeapVectorExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Off-heap vector API usage example started.");
+
+ System.out.println("\n>>> Creating perpendicular off-heap vectors.");
+ double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
+ double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
+
+ Vector v1 = new DenseLocalOffHeapVector(data1.length);
+ Vector v2 = new DenseLocalOffHeapVector(data2.length);
+
+ v1.assign(data1);
+ v2.assign(data2);
+
+ System.out.println(">>> First vector: " + Arrays.toString(data1));
+ System.out.println(">>> Second vector: " + Arrays.toString(data2));
+
+ double dotProduct = v1.dot(v2);
+ boolean dotProductIsAsExp = dotProduct == 0;
+
+ System.out.println("\n>>> Dot product of vectors: [" + dotProduct
+ + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
+
+ assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
+
+ Vector hypotenuse = v1.plus(v2);
+
+ System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
+
+ double lenSquared1 = v1.getLengthSquared();
+ double lenSquared2 = v2.getLengthSquared();
+ double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
+
+ boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
+
+ System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
+ System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
+ System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
+ + "], equals sum of squared lengths of two original vectors as expected: ["
+ + lenSquaredHypotenuseIsAsExp + "].");
+
+ assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
+
+ System.out.println("\n>>> Off-heap vector API usage example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/SparseVectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/SparseVectorExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/SparseVectorExample.java
new file mode 100644
index 0000000..f5678f6
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/SparseVectorExample.java
@@ -0,0 +1,80 @@
+/*
+ * 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.examples.ml.math.vector;
+
+import java.util.Arrays;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.vector.SparseLocalVector;
+
+import static org.apache.ignite.math.StorageConstants.RANDOM_ACCESS_MODE;
+
+/**
+ * This example shows how to use sparse {@link Vector} API.
+ */
+public final class SparseVectorExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Sparse vector API usage example started.");
+
+ System.out.println("\n>>> Creating perpendicular sparse vectors.");
+ double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
+ double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
+
+ Vector v1 = new SparseLocalVector(data1.length, RANDOM_ACCESS_MODE);
+ Vector v2 = new SparseLocalVector(data2.length, RANDOM_ACCESS_MODE);
+
+ v1.assign(data1);
+ v2.assign(data2);
+
+ System.out.println(">>> First vector: " + Arrays.toString(data1));
+ System.out.println(">>> Second vector: " + Arrays.toString(data2));
+
+ double dotProduct = v1.dot(v2);
+ boolean dotProductIsAsExp = dotProduct == 0;
+
+ System.out.println("\n>>> Dot product of vectors: [" + dotProduct
+ + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
+
+ assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
+
+ Vector hypotenuse = v1.plus(v2);
+
+ System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
+
+ double lenSquared1 = v1.getLengthSquared();
+ double lenSquared2 = v2.getLengthSquared();
+ double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
+
+ boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
+
+ System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
+ System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
+ System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
+ + "], equals sum of squared lengths of two original vectors as expected: ["
+ + lenSquaredHypotenuseIsAsExp + "].");
+
+ assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
+
+ System.out.println("\n>>> Sparse vector API usage example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorCustomStorageExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorCustomStorageExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorCustomStorageExample.java
new file mode 100644
index 0000000..2d549ae
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorCustomStorageExample.java
@@ -0,0 +1,124 @@
+/*
+ * 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.examples.ml.math.vector;
+
+import java.util.Arrays;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.vector.AbstractVector;
+
+/**
+ * This example shows how to use {@link Vector} based on custom {@link VectorStorage}.
+ */
+public final class VectorCustomStorageExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Vector custom storage API usage example started.");
+
+ System.out.println("\n>>> Creating perpendicular vectors.");
+ double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
+ double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
+
+ Vector v1 = new VectorCustomStorage(data1);
+ Vector v2 = new VectorCustomStorage(data2);
+
+ System.out.println(">>> First vector: " + Arrays.toString(data1));
+ System.out.println(">>> Second vector: " + Arrays.toString(data2));
+
+ double dotProduct = v1.dot(v2);
+ boolean dotProductIsAsExp = dotProduct == 0;
+
+ System.out.println("\n>>> Dot product of vectors: [" + dotProduct
+ + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
+
+ assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
+
+ Vector hypotenuse = v1.plus(v2);
+
+ System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
+
+ double lenSquared1 = v1.getLengthSquared();
+ double lenSquared2 = v2.getLengthSquared();
+ double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
+
+ boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
+
+ System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
+ System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
+ System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
+ + "], equals sum of squared lengths of two original vectors as expected: ["
+ + lenSquaredHypotenuseIsAsExp + "].");
+
+ assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
+
+ System.out.println("\n>>> Vector custom storage API usage example completed.");
+ }
+
+ /**
+ * Example of vector with custom storage, modeled after
+ * {@link org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector}.
+ */
+ static class VectorCustomStorage extends AbstractVector {
+ /**
+ * @param arr Source array.
+ * @param cp {@code true} to clone array, reuse it otherwise.
+ */
+ private VectorStorage mkStorage(double[] arr, boolean cp) {
+ assert arr != null;
+
+ return new ExampleVectorStorage(cp ? arr.clone() : arr);
+ }
+
+ /** */
+ public VectorCustomStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param arr Source array.
+ * @param shallowCp {@code true} to use shallow copy.
+ */
+ VectorCustomStorage(double[] arr, boolean shallowCp) {
+ setStorage(mkStorage(arr, shallowCp));
+ }
+
+ /**
+ * @param arr Source array.
+ */
+ VectorCustomStorage(double[] arr) {
+ this(arr, false);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return new DenseLocalOnHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc */
+ @Override public Vector like(int crd) {
+ return new org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector(crd);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorExample.java
new file mode 100644
index 0000000..d6971a7
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/VectorExample.java
@@ -0,0 +1,75 @@
+/*
+ * 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.examples.ml.math.vector;
+
+import java.util.Arrays;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+
+/**
+ * This example shows how to use {@link Vector} API.
+ */
+public final class VectorExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Basic Vector API usage example started.");
+
+ System.out.println("\n>>> Creating perpendicular vectors.");
+ double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
+ double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
+
+ Vector v1 = new DenseLocalOnHeapVector(data1);
+ Vector v2 = new DenseLocalOnHeapVector(data2);
+
+ System.out.println(">>> First vector: " + Arrays.toString(data1));
+ System.out.println(">>> Second vector: " + Arrays.toString(data2));
+
+ double dotProduct = v1.dot(v2);
+ boolean dotProductIsAsExp = dotProduct == 0;
+
+ System.out.println("\n>>> Dot product of vectors: [" + dotProduct
+ + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
+
+ assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
+
+ Vector hypotenuse = v1.plus(v2);
+
+ System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
+
+ double lenSquared1 = v1.getLengthSquared();
+ double lenSquared2 = v2.getLengthSquared();
+ double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
+
+ boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
+
+ System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
+ System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
+ System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
+ + "], equals sum of squared lengths of two original vectors as expected: ["
+ + lenSquaredHypotenuseIsAsExp + "].");
+
+ assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
+
+ System.out.println("\n>>> Basic Vector API usage example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/package-info.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/package-info.java
new file mode 100644
index 0000000..2cc74ac
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/vector/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. -->
+ * Core algebra vector examples.
+ */
+package org.apache.ignite.examples.ml.math.vector;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/README.txt
----------------------------------------------------------------------
diff --git a/modules/math/README.txt b/modules/math/README.txt
deleted file mode 100644
index a48da21..0000000
--- a/modules/math/README.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-Apache Ignite Math Module
-------------------------------
-
-Apache Ignite Math module provides several implementations of vector and matrices.
-
-Module includes on heap and off heap, dense and sparse, local and distributed implementations.
-
-Based on ideas from Apache Mahout.
-
-# Local build with javadoc
-
-Run from project root:
-mvn clean package -Pmath -DskipTests -pl modules/math -am
-
-Find generated jars in target folder.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/licenses/apache-2.0.txt
----------------------------------------------------------------------
diff --git a/modules/math/licenses/apache-2.0.txt b/modules/math/licenses/apache-2.0.txt
deleted file mode 100644
index d645695..0000000
--- a/modules/math/licenses/apache-2.0.txt
+++ /dev/null
@@ -1,202 +0,0 @@
-
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed 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.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/licenses/mit.txt
----------------------------------------------------------------------
diff --git a/modules/math/licenses/mit.txt b/modules/math/licenses/mit.txt
deleted file mode 100644
index 00217dc..0000000
--- a/modules/math/licenses/mit.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-Copyright <YEAR> <COPYRIGHT HOLDER>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/pom.xml
----------------------------------------------------------------------
diff --git a/modules/math/pom.xml b/modules/math/pom.xml
deleted file mode 100644
index d3b284e..0000000
--- a/modules/math/pom.xml
+++ /dev/null
@@ -1,109 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
- 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.
--->
-<!--
- POM file.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
-
- <parent>
- <artifactId>ignite-parent</artifactId>
- <groupId>org.apache.ignite</groupId>
- <version>1</version>
- <relativePath>../../parent</relativePath>
- </parent>
-
- <artifactId>ignite-math</artifactId>
- <version>2.0.0-SNAPSHOT</version>
- <url>http://ignite.apache.org</url>
-
- <properties>
- <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
- </properties>
-
- <dependencies>
- <dependency>
- <groupId>org.apache.ignite</groupId>
- <artifactId>ignite-core</artifactId>
- <version>${project.version}</version>
- </dependency>
-
- <dependency>
- <groupId>org.apache.ignite</groupId>
- <artifactId>ignite-core</artifactId>
- <version>${project.version}</version>
- <type>test-jar</type>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>it.unimi.dsi</groupId>
- <artifactId>fastutil</artifactId>
- <version>7.0.12</version>
- </dependency>
-
- <dependency>
- <!-- IMPL NOTE this is to write math benchmarks results, IGN-6530 -->
- <groupId>com.dropbox.core</groupId>
- <artifactId>dropbox-core-sdk</artifactId>
- <version>2.1.1</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>log4j</groupId>
- <artifactId>log4j</artifactId>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>spring-beans</artifactId>
- <version>${spring.version}</version>
- <scope>test</scope>
- </dependency>
-
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>spring-context</artifactId>
- <version>${spring.version}</version>
- <scope>test</scope>
- </dependency>
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <artifactId>maven-compiler-plugin</artifactId>
- <configuration>
- <source>1.8</source>
- <target>1.8</target>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
- <profiles>
- <profile>
- <id>math</id>
- </profile>
- </profiles>
-</project>
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/Algebra.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/Algebra.java b/modules/math/src/main/java/org/apache/ignite/math/Algebra.java
deleted file mode 100644
index 6bfd608..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/Algebra.java
+++ /dev/null
@@ -1,571 +0,0 @@
-/*
- * 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.
- */
-
-/*
-Copyright 1999 CERN - European Organization for Nuclear Research.
-Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
-is hereby granted without fee, provided that the above copyright notice appear in all copies and
-that both that copyright notice and this permission notice appear in supporting documentation.
-CERN makes no representations about the suitability of this software for any purpose.
-It is provided "as is" without expressed or implied warranty.
-*/
-
-package org.apache.ignite.math;
-
-/**
- * Miscellaneous arithmetic and algebra functions.
- * Lifted from Apache Mahout.
- */
-public class Algebra extends Constants {
- /** */ private static final double[] STIRLING_CORRECTION = {
- 0.0,
- 8.106146679532726e-02, 4.134069595540929e-02,
- 2.767792568499834e-02, 2.079067210376509e-02,
- 1.664469118982119e-02, 1.387612882307075e-02,
- 1.189670994589177e-02, 1.041126526197209e-02,
- 9.255462182712733e-03, 8.330563433362871e-03,
- 7.573675487951841e-03, 6.942840107209530e-03,
- 6.408994188004207e-03, 5.951370112758848e-03,
- 5.554733551962801e-03, 5.207655919609640e-03,
- 4.901395948434738e-03, 4.629153749334029e-03,
- 4.385560249232324e-03, 4.166319691996922e-03,
- 3.967954218640860e-03, 3.787618068444430e-03,
- 3.622960224683090e-03, 3.472021382978770e-03,
- 3.333155636728090e-03, 3.204970228055040e-03,
- 3.086278682608780e-03, 2.976063983550410e-03,
- 2.873449362352470e-03, 2.777674929752690e-03,
- };
-
- /** */ private static final double[] LOG_FACTORIALS = {
- 0.00000000000000000, 0.00000000000000000, 0.69314718055994531,
- 1.79175946922805500, 3.17805383034794562, 4.78749174278204599,
- 6.57925121201010100, 8.52516136106541430, 10.60460290274525023,
- 12.80182748008146961, 15.10441257307551530, 17.50230784587388584,
- 19.98721449566188615, 22.55216385312342289, 25.19122118273868150,
- 27.89927138384089157, 30.67186010608067280, 33.50507345013688888,
- 36.39544520803305358, 39.33988418719949404, 42.33561646075348503,
- 45.38013889847690803, 48.47118135183522388, 51.60667556776437357,
- 54.78472939811231919, 58.00360522298051994, 61.26170176100200198,
- 64.55753862700633106, 67.88974313718153498, 71.25703896716800901
- };
-
- /** */ private static final long[] LONG_FACTORIALS = {
- 1L,
- 1L,
- 2L,
- 6L,
- 24L,
- 120L,
- 720L,
- 5040L,
- 40320L,
- 362880L,
- 3628800L,
- 39916800L,
- 479001600L,
- 6227020800L,
- 87178291200L,
- 1307674368000L,
- 20922789888000L,
- 355687428096000L,
- 6402373705728000L,
- 121645100408832000L,
- 2432902008176640000L
- };
-
- /** */ private static final double[] DOUBLE_FACTORIALS = {
- 5.109094217170944E19,
- 1.1240007277776077E21,
- 2.585201673888498E22,
- 6.204484017332394E23,
- 1.5511210043330984E25,
- 4.032914611266057E26,
- 1.0888869450418352E28,
- 3.048883446117138E29,
- 8.841761993739701E30,
- 2.652528598121911E32,
- 8.222838654177924E33,
- 2.6313083693369355E35,
- 8.68331761881189E36,
- 2.952327990396041E38,
- 1.0333147966386144E40,
- 3.719933267899013E41,
- 1.3763753091226346E43,
- 5.23022617466601E44,
- 2.0397882081197447E46,
- 8.15915283247898E47,
- 3.34525266131638E49,
- 1.4050061177528801E51,
- 6.041526306337384E52,
- 2.6582715747884495E54,
- 1.196222208654802E56,
- 5.502622159812089E57,
- 2.5862324151116827E59,
- 1.2413915592536068E61,
- 6.082818640342679E62,
- 3.0414093201713376E64,
- 1.5511187532873816E66,
- 8.06581751709439E67,
- 4.274883284060024E69,
- 2.308436973392413E71,
- 1.2696403353658264E73,
- 7.109985878048632E74,
- 4.052691950487723E76,
- 2.350561331282879E78,
- 1.386831185456898E80,
- 8.32098711274139E81,
- 5.075802138772246E83,
- 3.146997326038794E85,
- 1.9826083154044396E87,
- 1.2688693218588414E89,
- 8.247650592082472E90,
- 5.443449390774432E92,
- 3.6471110918188705E94,
- 2.48003554243683E96,
- 1.7112245242814127E98,
- 1.1978571669969892E100,
- 8.504785885678624E101,
- 6.123445837688612E103,
- 4.470115461512686E105,
- 3.307885441519387E107,
- 2.4809140811395404E109,
- 1.8854947016660506E111,
- 1.451830920282859E113,
- 1.1324281178206295E115,
- 8.94618213078298E116,
- 7.15694570462638E118,
- 5.797126020747369E120,
- 4.7536433370128435E122,
- 3.94552396972066E124,
- 3.314240134565354E126,
- 2.8171041143805494E128,
- 2.4227095383672744E130,
- 2.107757298379527E132,
- 1.854826422573984E134,
- 1.6507955160908465E136,
- 1.4857159644817605E138,
- 1.3520015276784033E140,
- 1.2438414054641305E142,
- 1.156772507081641E144,
- 1.0873661566567426E146,
- 1.0329978488239061E148,
- 9.916779348709491E149,
- 9.619275968248216E151,
- 9.426890448883248E153,
- 9.332621544394415E155,
- 9.332621544394418E157,
- 9.42594775983836E159,
- 9.614466715035125E161,
- 9.902900716486178E163,
- 1.0299016745145631E166,
- 1.0813967582402912E168,
- 1.1462805637347086E170,
- 1.2265202031961373E172,
- 1.324641819451829E174,
- 1.4438595832024942E176,
- 1.5882455415227423E178,
- 1.7629525510902457E180,
- 1.974506857221075E182,
- 2.2311927486598138E184,
- 2.543559733472186E186,
- 2.925093693493014E188,
- 3.393108684451899E190,
- 3.96993716080872E192,
- 4.6845258497542896E194,
- 5.574585761207606E196,
- 6.689502913449135E198,
- 8.094298525273444E200,
- 9.875044200833601E202,
- 1.2146304367025332E205,
- 1.506141741511141E207,
- 1.882677176888926E209,
- 2.3721732428800483E211,
- 3.0126600184576624E213,
- 3.856204823625808E215,
- 4.974504222477287E217,
- 6.466855489220473E219,
- 8.471580690878813E221,
- 1.1182486511960037E224,
- 1.4872707060906847E226,
- 1.99294274616152E228,
- 2.690472707318049E230,
- 3.6590428819525483E232,
- 5.0128887482749884E234,
- 6.917786472619482E236,
- 9.615723196941089E238,
- 1.3462012475717523E241,
- 1.8981437590761713E243,
- 2.6953641378881633E245,
- 3.8543707171800694E247,
- 5.550293832739308E249,
- 8.047926057471989E251,
- 1.1749972043909107E254,
- 1.72724589045464E256,
- 2.5563239178728637E258,
- 3.8089226376305687E260,
- 5.7133839564458575E262,
- 8.627209774233244E264,
- 1.3113358856834527E267,
- 2.0063439050956838E269,
- 3.0897696138473515E271,
- 4.789142901463393E273,
- 7.471062926282892E275,
- 1.1729568794264134E278,
- 1.8532718694937346E280,
- 2.946702272495036E282,
- 4.714723635992061E284,
- 7.590705053947223E286,
- 1.2296942187394494E289,
- 2.0044015765453032E291,
- 3.287218585534299E293,
- 5.423910666131583E295,
- 9.003691705778434E297,
- 1.5036165148649983E300,
- 2.5260757449731988E302,
- 4.2690680090047056E304,
- 7.257415615308004E306
- };
-
- /**
- * Efficiently returns the binomial coefficient, often also referred to as
- * "n over k" or "n choose k". The binomial coefficient is defined as
- * {@code (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )}.
- * <ul> <li>{@code k<0}: {@code 0}.</li>
- * <li>{@code k==0}: {@code 1}.</li>
- * <li>{@code k==1}: {@code n}.</li>
- * <li>else: {@code (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k)}.</li>
- * </ul>
- *
- * @param n
- * @param k
- * @return Binomial coefficient.
- */
- public static double binomial(double n, long k) {
- if (k < 0)
- return 0;
-
- if (k == 0)
- return 1;
-
- if (k == 1)
- return n;
-
- // binomial(n,k) = (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )
- double a = n - k + 1;
- double b = 1;
- double binomial = 1;
-
- for (long i = k; i-- > 0; )
- binomial *= (a++) / (b++);
-
- return binomial;
- }
-
- /**
- * Efficiently returns the binomial coefficient, often also referred to as "n over k" or "n choose k".
- * The binomial coefficient is defined as
- * <ul> <li>{@code k<0}: {@code 0}. <li>{@code k==0 || k==n}: {@code 1}. <li>{@code k==1 || k==n-1}:
- * {@code n}. <li>else: {@code (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )}. </ul>
- *
- * @param n
- * @param k
- * @return Binomial coefficient.
- */
- public static double binomial(long n, long k) {
- if (k < 0)
- return 0;
-
- if (k == 0 || k == n)
- return 1;
-
- if (k == 1 || k == n - 1)
- return n;
-
- if (n > k) {
- int max = LONG_FACTORIALS.length + DOUBLE_FACTORIALS.length;
-
- if (n < max) {
- double nFac = factorial((int)n);
- double kFac = factorial((int)k);
- double nMinusKFac = factorial((int)(n - k));
- double nk = nMinusKFac * kFac;
-
- if (nk != Double.POSITIVE_INFINITY) // No numeric overflow?
- return nFac / nk;
- }
-
- if (k > n / 2)
- k = n - k;
- }
-
- // binomial(n,k) = (n * n-1 * ... * n-k+1 ) / ( 1 * 2 * ... * k )
- long a = n - k + 1;
- long b = 1;
- double binomial = 1;
-
- for (long i = k; i-- > 0; )
- binomial *= (double)a++ / (b++);
-
- return binomial;
- }
-
- /**
- * Returns the smallest <code>long >= value</code>.
- * <dl><dt>Examples: {@code 1.0 -> 1, 1.2 -> 2, 1.9 -> 2}. This
- * method is safer than using (long) Math.ceil(value), because of possible rounding error.</dt></dl>
- *
- * @param val
- */
- public static long ceil(double val) {
- return Math.round(Math.ceil(val));
- }
-
- /**
- * Evaluates the series of Chebyshev polynomials Ti at argument x/2. The series is given by
- * <pre>
- * N-1
- * - '
- * y = > coef[i] T (x/2)
- * - i
- * i=0
- * </pre>
- * Coefficients are stored in reverse order, i.e. the zero order term is last in the array. Note N is the number of
- * coefficients, not the order. <p> If coefficients are for the interval a to b, x must have been transformed to x
- * -< 2(2x - b - a)/(b-a) before entering the routine. This maps x from (a, b) to (-1, 1), over which the
- * Chebyshev polynomials are defined. <p> If the coefficients are for the inverted interval, in which (a, b) is
- * mapped to (1/b, 1/a), the transformation required is {@code x -> 2(2ab/x - b - a)/(b-a)}. If b is infinity, this
- * becomes {@code x -> 4a/x - 1}. <p> SPEED: <p> Taking advantage of the recurrence properties of the Chebyshev
- * polynomials, the routine requires one more addition per loop than evaluating a nested polynomial of the same
- * degree.
- *
- * @param x Argument to the polynomial.
- * @param coef Coefficients of the polynomial.
- * @param N Number of coefficients.
- */
- public static double chbevl(double x, double[] coef, int N) {
- int p = 0;
-
- double b0 = coef[p++];
- double b1 = 0.0;
- int i = N - 1;
-
- double b2;
-
- do {
- b2 = b1;
- b1 = b0;
- b0 = x * b1 - b2 + coef[p++];
- }
- while (--i > 0);
-
- return 0.5 * (b0 - b2);
- }
-
- /**
- * Instantly returns the factorial {@code k!}.
- *
- * @param k must hold {@code k >= 0}.
- */
- private static double factorial(int k) {
- if (k < 0)
- throw new IllegalArgumentException();
-
- int len1 = LONG_FACTORIALS.length;
-
- if (k < len1)
- return LONG_FACTORIALS[k];
-
- int len2 = DOUBLE_FACTORIALS.length;
-
- return (k < len1 + len2) ? DOUBLE_FACTORIALS[k - len1] : Double.POSITIVE_INFINITY;
- }
-
- /**
- * Returns the largest <code>long <= value</code>.
- * <dl><dt>Examples: {@code 1.0 -> 1, 1.2 -> 1, 1.9 -> 1 <dt> 2.0 -> 2, 2.2 -> 2, 2.9 -> 2}</dt></dl>
- * This method is safer than using (long) Math.floor(value), because of possible rounding error.
- */
- public static long floor(double val) {
- return Math.round(Math.floor(val));
- }
-
- /**
- * Returns {@code log<sub>base</sub>value}.
- */
- public static double log(double base, double val) {
- return Math.log(val) / Math.log(base);
- }
-
- /**
- * Returns {@code log<sub>10</sub>value}.
- */
- public static double log10(double val) {
- // 1.0 / Math.log(10) == 0.43429448190325176
- return Math.log(val) * 0.43429448190325176;
- }
-
- /**
- * Returns {@code log<sub>2</sub>value}.
- */
- public static double log2(double val) {
- // 1.0 / Math.log(2) == 1.4426950408889634
- return Math.log(val) * 1.4426950408889634;
- }
-
- /**
- * Returns {@code log(k!)}. Tries to avoid overflows. For {@code k<30} simply looks up a table in O(1).
- * For {@code k>=30} uses stirlings approximation.
- *
- * @param k must hold {@code k >= 0}.
- */
- public static double logFactorial(int k) {
- if (k >= 30) {
- double r = 1.0 / k;
- double rr = r * r;
- double C7 = -5.95238095238095238e-04;
- double C5 = 7.93650793650793651e-04;
- double C3 = -2.77777777777777778e-03;
- double C1 = 8.33333333333333333e-02;
- double C0 = 9.18938533204672742e-01;
-
- return (k + 0.5) * Math.log(k) - k + C0 + r * (C1 + rr * (C3 + rr * (C5 + rr * C7)));
- }
- else
- return LOG_FACTORIALS[k];
- }
-
- /**
- * Instantly returns the factorial {@code k!}.
- *
- * @param k must hold {@code k >= 0 && k < 21}
- */
- public static long longFactorial(int k) {
- if (k < 0)
- throw new IllegalArgumentException("Negative k");
-
- if (k < LONG_FACTORIALS.length)
- return LONG_FACTORIALS[k];
-
- throw new IllegalArgumentException("Overflow");
- }
-
- /**
- * Returns the StirlingCorrection.
- *
- * Correction term of the Stirling approximation for {@code log(k!)} (series in
- * 1/k, or table values for small k) with int parameter k. </p> {@code log k! = (k + 1/2)log(k + 1) - (k + 1) +
- * (1/2)log(2Pi) + STIRLING_CORRECTION(k + 1) log k! = (k + 1/2)log(k) - k + (1/2)log(2Pi) +
- * STIRLING_CORRECTION(k) }
- */
- public static double stirlingCorrection(int k) {
- if (k > 30) {
- double r = 1.0 / k;
- double rr = r * r;
- double C7 = -5.95238095238095238e-04;
- double C5 = 7.93650793650793651e-04;
- double C3 = -2.77777777777777778e-03;
- double C1 = 8.33333333333333333e-02;
-
- return r * (C1 + rr * (C3 + rr * (C5 + rr * C7)));
- }
- else
- return STIRLING_CORRECTION[k];
- }
-
- /**
- * Evaluates the given polynomial of degree {@code N} at {@code x}, assuming coefficient of N is 1.0. Otherwise same
- * as {@link #evalPoly(double, double[], int)}.
- * <pre>
- * 2 N
- * y = C + C x + C x +...+ C x
- * 0 1 2 N
- *
- * where C = 1 and hence is omitted from the array.
- * N
- *
- * Coefficients are stored in reverse order:
- *
- * coef[0] = C , ..., coef[N-1] = C .
- * N-1 0
- *
- * Calling arguments are otherwise the same as {@link #evalPoly(double, double[], int)}.
- * </pre>
- * In the interest of speed, there are no checks for out of bounds arithmetic.
- *
- * @param x Argument to the polynomial.
- * @param coef Coefficients of the polynomial.
- * @param n Degree of the polynomial.
- */
- public static double evalPoly1(double x, double[] coef, int n) {
- double res = x + coef[0];
-
- for (int i = 1; i < n; i++)
- res = res * x + coef[i];
-
- return res;
- }
-
- /**
- * Evaluates the given polynomial of degree {@code N} at {@code x}.
- * <pre>
- * 2 N
- * y = C + C x + C x +...+ C x
- * 0 1 2 N
- *
- * Coefficients are stored in reverse order:
- *
- * coef[0] = C , ..., coef[N] = C .
- * N 0
- * </pre>
- * In the interest of speed, there are no checks for out of bounds arithmetic.
- *
- * @param x Argument to the polynomial.
- * @param coef Coefficients of the polynomial.
- * @param n Degree of the polynomial.
- */
- public static double evalPoly(double x, double[] coef, int n) {
- double res = coef[0];
-
- for (int i = 1; i <= n; i++)
- res = res * x + coef[i];
-
- return res;
- }
-
- /**
- * Gets <code>sqrt(a^2 + b^2)</code> without under/overflow.
- *
- * @param a
- * @param b
- */
- public static double hypot(double a, double b) {
- double r;
-
- if (Math.abs(a) > Math.abs(b)) {
- r = b / a;
- r = Math.abs(a) * Math.sqrt(1 + r * r);
- }
- else if (b != 0) {
- r = a / b;
- r = Math.abs(b) * Math.sqrt(1 + r * r);
- }
- else
- r = 0.0;
-
- return r;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/Constants.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/Constants.java b/modules/math/src/main/java/org/apache/ignite/math/Constants.java
deleted file mode 100644
index 02756b6..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/Constants.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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.
- */
-
-/*
-Copyright 1999 CERN - European Organization for Nuclear Research.
-Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
-is hereby granted without fee, provided that the above copyright notice appear in all copies and
-that both that copyright notice and this permission notice appear in supporting documentation.
-CERN makes no representations about the suitability of this software for any purpose.
-It is provided "as is" without expressed or implied warranty.
-*/
-
-package org.apache.ignite.math;
-
-/**
- * Math constants. Lifted from Apache Mahout.
- */
-public class Constants {
- /** */ public static final double MACHEP = 1.11022302462515654042E-16;
- /** */ public static final double MAXLOG = 7.09782712893383996732E2;
- /** */ public static final double MINLOG = -7.451332191019412076235E2;
- /** */ public static final double MAXGAM = 171.624376956302725;
- /** */ public static final double SQTPI = 2.50662827463100050242E0;
- /** */ public static final double SQRTH = 7.07106781186547524401E-1;
- /** */ public static final double LOGPI = 1.14472988584940017414;
- /** */ public static final double BIG = 4.503599627370496e15;
- /** */ public static final double BIGINV = 2.22044604925031308085e-16;
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/Destroyable.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/Destroyable.java b/modules/math/src/main/java/org/apache/ignite/math/Destroyable.java
deleted file mode 100644
index f3b467c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/Destroyable.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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;
-
-/**
- * Support for destroying objects that are managed outside of JVM.
- */
-public interface Destroyable {
- /**
- * Destroys object if managed outside of JVM. It's a no-op in all other cases.
- */
- public default void destroy() {
- // No-op.
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/IdentityValueMapper.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/IdentityValueMapper.java b/modules/math/src/main/java/org/apache/ignite/math/IdentityValueMapper.java
deleted file mode 100644
index 65c7024..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/IdentityValueMapper.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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;
-
-/**
- * Identity value mapper.
- */
-public class IdentityValueMapper implements ValueMapper<Double> {
- /** */ private static final long serialVersionUID = -8010078306142216389L;
-
- /** {@inheritDoc} */
- @Override public Double fromDouble(double v) {
- return v;
- }
-
- /** {@inheritDoc} */
- @Override public double toDouble(Double v) {
- assert v != null;
-
- return v;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- return Long.hashCode(serialVersionUID);
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- return true;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/KeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/KeyMapper.java b/modules/math/src/main/java/org/apache/ignite/math/KeyMapper.java
deleted file mode 100644
index f4f9a39..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/KeyMapper.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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;
-
-import java.io.Serializable;
-
-/**
- * Maps key objects to index in {@link Vector} or {@link Matrix}.
- */
-public interface KeyMapper<K> extends Serializable {
- /**
- * Checks given cache key corresponds to a valid index in vector or matrix.
- *
- * @param k Key to check.
- * @return {@code true} if there is a valid index, {@code false} otherwise.
- */
- public boolean isValid(K k);
-}
[06/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java
new file mode 100644
index 0000000..8f32a89
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java
@@ -0,0 +1,139 @@
+/*
+ * 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.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.impls.storage.vector.MatrixVectorStorage;
+
+/**
+ * Row or column vector view off the matrix.
+ */
+public class MatrixVectorView extends AbstractVector {
+ /** */ private Matrix parent;
+
+ /** */ private int row;
+ /** */ private int col;
+
+ /** */ private int rowStride;
+ /** */ private int colStride;
+
+ /**
+ *
+ */
+ public MatrixVectorView() {
+ // No-op.
+ }
+
+ /**
+ * @param parent
+ * @param row
+ * @param col
+ * @param rowStride
+ * @param colStride
+ */
+ public MatrixVectorView(Matrix parent, int row, int col, int rowStride, int colStride) {
+ assert parent != null;
+
+ if (row < 0 || row >= parent.rowSize())
+ throw new IndexException(row);
+ if (col < 0 || col >= parent.columnSize())
+ throw new IndexException(col);
+
+ this.parent = parent;
+
+ this.row = row;
+ this.col = col;
+
+ this.rowStride = rowStride;
+ this.colStride = colStride;
+
+ setStorage(new MatrixVectorStorage(parent, row, col, rowStride, colStride));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ return new MatrixVectorView(parent, row, col, rowStride, colStride);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ return parent.likeVector(crd);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return parent.like(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeObject(parent);
+ out.writeInt(row);
+ out.writeInt(col);
+ out.writeInt(rowStride);
+ out.writeInt(colStride);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ parent = (Matrix)in.readObject();
+ row = in.readInt();
+ col = in.readInt();
+ rowStride = in.readInt();
+ colStride = in.readInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + (parent == null ? 0 : parent.hashCode());
+ res = res * 37 + row;
+ res = res * 37 + col;
+ res = res * 37 + rowStride;
+ res = res * 37 + colStride;
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ MatrixVectorView that = (MatrixVectorView)o;
+
+ return (parent != null ? parent.equals(that.parent) : that.parent == null) &&
+ row == that.row &&
+ col == that.col &&
+ rowStride == that.rowStride &&
+ colStride == that.colStride;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java
new file mode 100644
index 0000000..cc9e835
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java
@@ -0,0 +1,163 @@
+/*
+ * 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.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.impls.storage.vector.PivotedVectorStorage;
+
+/**
+ * Pivoted (index mapped) view over another vector.
+ */
+public class PivotedVectorView extends AbstractVector {
+ /** */ private Vector vec;
+
+ /**
+ * @param vec
+ * @param pivot Mapping from external index to internal.
+ * @param unpivot Mapping from internal index to external.
+ */
+ public PivotedVectorView(Vector vec, int[] pivot, int[] unpivot) {
+ setStorage(new PivotedVectorStorage(vec.getStorage(), pivot, unpivot));
+
+ checkCardinality(pivot);
+ checkCardinality(unpivot);
+
+ this.vec = vec;
+ }
+
+ /**
+ * @param vec
+ * @param pivot
+ */
+ public PivotedVectorView(Vector vec, int[] pivot) {
+ setStorage(new PivotedVectorStorage(vec.getStorage(), pivot));
+
+ checkCardinality(pivot);
+
+ this.vec = vec;
+ }
+
+ /**
+ *
+ *
+ */
+ private PivotedVectorStorage storage() {
+ return (PivotedVectorStorage)getStorage();
+ }
+
+ /**
+ *
+ */
+ public PivotedVectorView() {
+ // No-op.
+ }
+
+ /**
+ *
+ *
+ */
+ public Vector getBaseVector() {
+ return vec;
+ }
+
+ /**
+ * @param i
+ */
+ public int pivot(int i) {
+ return storage().pivot()[i];
+ }
+
+ /**
+ * @param i
+ */
+ public int unpivot(int i) {
+ return storage().unpivot()[i];
+ }
+
+ /**
+ * @param idx
+ */
+ protected Vector.Element makeElement(int idx) {
+ checkIndex(idx);
+
+ // External index.
+ int exIdx = storage().pivot()[idx];
+
+ return new Vector.Element() {
+ /** {@inheritDoc */
+ @Override public double get() {
+ return storageGet(idx);
+ }
+
+ /** {@inheritDoc */
+ @Override public int index() {
+ return exIdx;
+ }
+
+ /** {@inheritDoc */
+ @Override public void set(double val) {
+ storageSet(idx, val);
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ PivotedVectorStorage sto = storage();
+
+ return new PivotedVectorView(vec, sto.pivot(), sto.unpivot());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return vec.likeMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ if (x == 0.0)
+ return copy().map(Functions.mult(x));
+ else
+ return super.times(x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeObject(vec);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ vec = (Vector)in.readObject();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java
new file mode 100644
index 0000000..c9121c9
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java
@@ -0,0 +1,128 @@
+/*
+ * 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.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Map;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.matrix.RandomMatrix;
+import org.apache.ignite.math.impls.storage.vector.RandomVectorStorage;
+
+/**
+ * Random vector. Each value is taken from {-1,0,1} with roughly equal probability. Note
+ * that by default, the value is determined by a relatively simple hash of the index.
+ */
+public class RandomVector extends AbstractReadOnlyVector {
+ /** */ private boolean fastHash;
+
+ /**
+ * @param size Vector cardinality.
+ * @param fastHash
+ */
+ private VectorStorage mkStorage(int size, boolean fastHash) {
+ this.fastHash = fastHash;
+
+ return new RandomVectorStorage(size, fastHash);
+ }
+
+ /**
+ * @param size
+ * @param fastHash
+ */
+ public RandomVector(int size, boolean fastHash) {
+ setStorage(mkStorage(size, fastHash));
+ }
+
+ /**
+ * @param size
+ */
+ public RandomVector(int size) {
+ this(size, true);
+ }
+
+ /**
+ * @param args
+ */
+ public RandomVector(Map<String, Object> args) {
+ assert args != null;
+
+ if (args.containsKey("size") && args.containsKey("fastHash"))
+ setStorage(mkStorage((int)args.get("size"), (boolean)args.get("fastHash")));
+ else if (args.containsKey("size"))
+ setStorage(mkStorage((int)args.get("size"), true));
+ else
+ throw new UnsupportedOperationException("Invalid constructor argument(s).");
+ }
+
+ /** */
+ public RandomVector() {
+ // No-op.
+ }
+
+ /** {@inheritDoc} */
+ @Override public org.apache.ignite.math.Vector like(int crd) {
+ return new RandomVector(crd, fastHash);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return new RandomMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeBoolean(fastHash);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ fastHash = in.readBoolean();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + Boolean.hashCode(fastHash);
+ res = res * 37 + getStorage().hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ RandomVector that = (RandomVector)o;
+ VectorStorage sto = getStorage();
+
+ return fastHash == that.fastHash && (sto != null ? sto.equals(that.getStorage()) : that.getStorage() == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java
new file mode 100644
index 0000000..8d19ee0
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java
@@ -0,0 +1,102 @@
+/*
+ * 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.vector;
+
+import java.util.Map;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.storage.vector.SingleElementVectorStorage;
+
+/**
+ * Read-write vector holding a single non-zero value at some index.
+ */
+public class SingleElementVector extends AbstractVector {
+ /**
+ *
+ */
+ public SingleElementVector() {
+ // No-op
+ }
+
+ /**
+ * @param size
+ * @param idx
+ * @param val
+ */
+ public SingleElementVector(int size, int idx, double val) {
+ super(new SingleElementVectorStorage(size, idx, val));
+ }
+
+ /**
+ * @param args
+ */
+ public SingleElementVector(Map<String, Object> args) {
+ assert args != null;
+
+ if (args.containsKey("size") && args.containsKey("index") && args.containsKey("value")) {
+ int size = (int)args.get("size");
+ int idx = (int)args.get("index");
+ double val = (double)args.get("value");
+
+ setStorage(new SingleElementVectorStorage(size, idx, val));
+ }
+ else
+ throw new UnsupportedOperationException("Invalid constructor argument(s).");
+ }
+
+ /**
+ *
+ *
+ */
+ private SingleElementVectorStorage storage() {
+ return (SingleElementVectorStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element minElement() {
+ return makeElement(storage().index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element maxElement() {
+ return makeElement(storage().index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ return getX(storage().index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public int nonZeroElements() {
+ return isZero(get(storage().index())) ? 0 : 1;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ int idx = storage().index();
+
+ return new SingleElementVector(crd, idx, getX(idx));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java
new file mode 100644
index 0000000..76a1c0a
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java
@@ -0,0 +1,97 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.impls.storage.vector.SingleElementVectorDelegateStorage;
+
+/**
+ * Single value vector view over another vector.
+ */
+public class SingleElementVectorView extends AbstractVector {
+ /**
+ *
+ */
+ public SingleElementVectorView() {
+ // No-op.
+ }
+
+ /**
+ * @param vec
+ * @param idx
+ */
+ public SingleElementVectorView(Vector vec, int idx) {
+ super(new SingleElementVectorDelegateStorage(vec, idx));
+ }
+
+ /**
+ *
+ *
+ */
+ private SingleElementVectorDelegateStorage storage() {
+ return (SingleElementVectorDelegateStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector.Element minElement() {
+ return makeElement(storage().index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector.Element maxElement() {
+ return makeElement(storage().index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ return getX(storage().index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public int nonZeroElements() {
+ return isZero(getX(storage().index())) ? 0 : 1;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ SingleElementVectorDelegateStorage sto = storage();
+
+ return new SingleElementVectorView(sto.delegate(), sto.index());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ if (x == 0.0)
+ return copy().map(Functions.mult(x));
+ else
+ return super.times(x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java
new file mode 100644
index 0000000..2fd1c57
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java
@@ -0,0 +1,47 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.storage.vector.SparseLocalOffHeapVectorStorage;
+
+/**
+ * Implementation for {@link Vector} assuming sparse logic and local offheap JVM storage.
+ * It is suitable for data sets where local, non-distributed execution is satisfactory and on-heap JVM storage
+ * is not enough to keep the entire data set.
+ * <p>See also: <a href="https://en.wikipedia.org/wiki/Sparse_array">Wikipedia article</a>.</p>
+ */
+public class SparseLocalOffHeapVector extends AbstractVector {
+ /**
+ * @param crd Vector cardinality.
+ */
+ public SparseLocalOffHeapVector(int crd) {
+ setStorage(new SparseLocalOffHeapVectorStorage(crd));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ return new SparseLocalOffHeapVector(crd);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return null;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java
new file mode 100644
index 0000000..ebb6731
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java
@@ -0,0 +1,71 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.storage.vector.SparseLocalOnHeapVectorStorage;
+
+/**
+ * Local on-heap sparse vector based on hash map storage.
+ */
+public class SparseLocalVector extends AbstractVector implements StorageConstants {
+ /**
+ *
+ */
+ public SparseLocalVector() {
+ // No-op.
+ }
+
+ /**
+ * @param size
+ * @param acsMode
+ */
+ public SparseLocalVector(int size, int acsMode) {
+ assertAccessMode(acsMode);
+
+ setStorage(new SparseLocalOnHeapVectorStorage(size, acsMode));
+ }
+
+ /** */
+ private SparseLocalOnHeapVectorStorage storage() {
+ return (SparseLocalOnHeapVectorStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ SparseLocalOnHeapVectorStorage sto = storage();
+
+ return new SparseLocalVector(crd, sto.getAccessMode());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ return new SparseLocalOnHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(double x) {
+ if (x == 0.0)
+ return assign(0);
+ else
+ return super.times(x);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java
new file mode 100644
index 0000000..ce51a45
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java
@@ -0,0 +1,85 @@
+/*
+ * 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.vector;
+
+import java.io.Externalizable;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.storage.vector.DelegateVectorStorage;
+
+/**
+ * Implements the partial view into the parent {@link Vector}.
+ */
+public class VectorView extends AbstractVector {
+ /**
+ * Constructor for {@link Externalizable} interface.
+ */
+ public VectorView() {
+ // No-op.
+ }
+
+ /**
+ * @param parent Backing parent {@link Vector}.
+ * @param off Offset to parent vector.
+ * @param len Size of the view.
+ */
+ public VectorView(Vector parent, int off, int len) {
+ super(new DelegateVectorStorage(parent.getStorage(), off, len));
+ }
+
+ /**
+ * @param sto Backing parent {@link VectorStorage}.
+ * @param off Offset to parent vector.
+ * @param len Size of the view.
+ */
+ public VectorView(VectorStorage sto, int off, int len) {
+ super(new DelegateVectorStorage(sto, off, len));
+ }
+
+ /** */
+ private DelegateVectorStorage storage() {
+ return (DelegateVectorStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector copy() {
+ DelegateVectorStorage sto = storage();
+
+ return new VectorView(sto.delegate(), sto.offset(), sto.length());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector like(int crd) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix likeMatrix(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ return this == o ||
+ ((o != null)
+ && o.getClass() == getClass()
+ && (getStorage().equals(((VectorView)o).getStorage())));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/package-info.java
new file mode 100644
index 0000000..d6ca1f3
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/vector/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 specific implementations for vectors.
+ */
+package org.apache.ignite.math.impls.vector;
\ 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/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/package-info.java
new file mode 100644
index 0000000..05ce651
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/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 main APIs for distributed code algebra.
+ */
+package org.apache.ignite.math;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/resources/org/apache/ignite/math/d3-matrix-template.html
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/resources/org/apache/ignite/math/d3-matrix-template.html b/modules/ml/src/main/resources/org/apache/ignite/math/d3-matrix-template.html
new file mode 100644
index 0000000..19a907a
--- /dev/null
+++ b/modules/ml/src/main/resources/org/apache/ignite/math/d3-matrix-template.html
@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<!--
+ 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.
+-->
+<meta charset="utf-8">
+<title>IgniteML</title>
+<style>
+ body {
+ margin: 0 15px;
+ }
+
+ p {
+ margin: 10px 0 !important;
+ }
+
+ .name {
+ font-size: 20px;
+ font-weight: 400;
+ font-family: monospace;
+ }
+
+ .swatch {
+ display: inline-block;
+ width: 25px;
+ height: 25px;
+ margin-left: 5px;
+ vertical-align: bottom;
+ }
+</style>
+<body>
+<img style="margin-top: 15px" width="100px" src="https://ignite.apache.org/images/logo3.png">
+<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.min.js"></script>
+<script>
+ /*@DATA@*/
+ var data = [[{d: 2.256, r: 198, g: 128, b: 128}, {d: 0.123, r: 218, g: 228, b: 18}], [{
+ d: 2.256,
+ r: 108,
+ g: 28,
+ b: 108
+ }, {d: 0.123, r: 228, g: 228, b: 228}]];
+ /*@MAX@*/
+ var max = {d: 2.256, r: 128, g: 128, b: 128};
+ /*@MIN@*/
+ var min = {d: 0.123, r: 228, g: 228, b: 228};
+ /*@NAME@*/
+ var name = "Matrix";
+
+ var rows = data.length;
+ var cols = data[0].length;
+
+ var range = max.d - min.d;
+
+ var rw, rh;
+ var W, H;
+
+ if (cols > W) {
+ rw = 1;
+ W = cols;
+ }
+ else {
+ W = 1000;
+ rw = Math.min(Math.round(W / cols), 10);
+ }
+
+ if (rows > H) {
+ rh = 1;
+ H = rows;
+ }
+ else {
+ H = 1000;
+ rh = Math.min(Math.round(H / rows), 10);
+ }
+
+ d3.selectAll("body")
+ .append("p")
+ .text(name + " (" + rows + "x" + cols + ")")
+ .attr("class", "name");
+
+ d3.selectAll("body")
+ .append("p")
+ .attr("class", "name")
+ .text("Max: " + max.d)
+ .append("span")
+ .attr("class", "swatch")
+ .attr("style", "background-color: rgb(" + max.r + ", " + max.g + ", " + max.b + ")");
+
+ d3.selectAll("body")
+ .append("p")
+ .attr("class", "name")
+ .text("Min: " + min.d)
+ .append("span")
+ .attr("class", "swatch")
+ .attr("style", "background-color: rgb(" + min.r + ", " + min.g + ", " + min.b + ")");
+
+ var svg = d3.select("body").append("svg")
+ .attr("width", W)
+ .attr("height", H);
+
+ var y = 0;
+
+ for (var row = 0; row < rows; row++)
+ svg.selectAll("div")
+ .data(data[row])
+ .enter()
+ .append("rect")
+ .attr("x", function (d, i) {
+ return i * rw
+ })
+ .attr("y", rh * row)
+ .attr("fill", function (d) {
+ return "rgb(" + d.r + ", " + d.g + ", " + d.b + ")";
+ })
+ .attr("width", rw)
+ .attr("height", rh);
+</script>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/resources/org/apache/ignite/math/d3-vector-template.html
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/resources/org/apache/ignite/math/d3-vector-template.html b/modules/ml/src/main/resources/org/apache/ignite/math/d3-vector-template.html
new file mode 100644
index 0000000..7644481
--- /dev/null
+++ b/modules/ml/src/main/resources/org/apache/ignite/math/d3-vector-template.html
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<!--
+ 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.
+-->
+<meta charset="utf-8">
+<title>IgniteML</title>
+<style>
+ body {
+ margin: 0 15px;
+ }
+
+ p {
+ margin: 10px 0 !important;
+ }
+
+ .name {
+ font-size: 20px;
+ font-weight: 400;
+ font-family: monospace;
+ }
+
+ .swatch {
+ display: inline-block;
+ width: 25px;
+ height: 25px;
+ margin-left: 5px;
+ vertical-align: bottom;
+ }
+</style>
+<body>
+<img style="margin-top: 15px" width="100px" src="https://ignite.apache.org/images/logo3.png">
+<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.min.js"></script>
+<script>
+ /*@DATA@*/
+ var data = [{d: 2.256, r: 128, g: 128, b: 128}, {d: 0.123, r: 228, g: 228, b: 228}];
+ /*@MAX@*/
+ var max = {d: 2.256, r: 128, g: 128, b: 128};
+ /*@MIN@*/
+ var min = {d: 0.123, r: 228, g: 228, b: 228};
+ /*@NAME@*/
+ var name = "Vector";
+
+ var W, H = 1000;
+
+ var range = max.d - min.d;
+
+ var rh = 20; // Constant.
+
+ var rw;
+
+ if (data.length > W) {
+ rw = 1;
+ W = data.length;
+ }
+ else {
+ W = 1000;
+ rw = Math.min(Math.round(W / data.length), 5);
+ }
+
+ d3.selectAll("body")
+ .append("p")
+ .text(name + " (size: " + data.length + ")")
+ .attr("class", "name");
+
+ d3.selectAll("body")
+ .append("p")
+ .attr("class", "name")
+ .text("Max: " + max.d)
+ .append("span")
+ .attr("class", "swatch")
+ .attr("style", "background-color: rgb(" + max.r + ", " + max.g + ", " + max.b + ")");
+
+ d3.selectAll("body")
+ .append("p")
+ .attr("class", "name")
+ .text("Min: " + min.d)
+ .append("span")
+ .attr("class", "swatch")
+ .attr("style", "background-color: rgb(" + min.r + ", " + min.g + ", " + min.b + ")");
+
+ var svg = d3.select("body").append("svg")
+ .attr("width", W)
+ .attr("height", H);
+
+ svg.selectAll("rect")
+ .data(data)
+ .enter()
+ .append("rect")
+ .attr("x", function (d, i) {
+ return i * rw
+ })
+ .attr("y", 10)
+ .attr("fill", function (d) {
+ return "rgb(" + d.r + ", " + d.g + ", " + d.b + ")";
+ })
+ .attr("width", rw)
+ .attr("height", rh);
+</script>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/ExternalizeTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/ExternalizeTest.java b/modules/ml/src/test/java/org/apache/ignite/math/ExternalizeTest.java
new file mode 100644
index 0000000..218b7ff
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/ExternalizeTest.java
@@ -0,0 +1,66 @@
+/*
+ * 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;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Common test for externalization.
+ */
+public abstract class ExternalizeTest<T extends Externalizable & Destroyable> {
+ /** */
+ protected void externalizeTest(T initObj) {
+ T objRestored = null;
+
+ try {
+ ByteArrayOutputStream byteArrOutputStream = new ByteArrayOutputStream();
+ ObjectOutputStream objOutputStream = new ObjectOutputStream(byteArrOutputStream);
+
+ objOutputStream.writeObject(initObj);
+
+ ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(byteArrOutputStream.toByteArray());
+ ObjectInputStream objInputStream = new ObjectInputStream(byteArrInputStream);
+
+ objRestored = (T)objInputStream.readObject();
+
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, initObj.equals(objRestored));
+ assertTrue(MathTestConstants.VAL_NOT_EQUALS, Integer.compare(initObj.hashCode(), objRestored.hashCode()) == 0);
+ }
+ catch (ClassNotFoundException | IOException e) {
+ fail(e + " [" + e.getMessage() + "]");
+ }
+ finally {
+ if (objRestored != null)
+ objRestored.destroy();
+ }
+ }
+
+ /** */
+ @Test
+ public abstract void externalizeTest();
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java b/modules/ml/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java
new file mode 100644
index 0000000..318ea95
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java
@@ -0,0 +1,39 @@
+/*
+ * 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;
+
+import org.apache.ignite.math.impls.matrix.CacheMatrixTest;
+import org.apache.ignite.math.impls.matrix.SparseDistributedMatrixTest;
+import org.apache.ignite.math.impls.storage.matrix.SparseDistributedMatrixStorageTest;
+import org.apache.ignite.math.impls.vector.CacheVectorTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Test suite for all distributed tests located in org.apache.ignite.math.impls.* package.
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ CacheVectorTest.class,
+ CacheMatrixTest.class,
+ SparseDistributedMatrixStorageTest.class,
+ SparseDistributedMatrixTest.class,
+})
+public class MathImplDistributedTestSuite {
+ // No-op.
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java b/modules/ml/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java
new file mode 100644
index 0000000..a652e7f
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java
@@ -0,0 +1,123 @@
+/*
+ * 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;
+
+import org.apache.ignite.math.decompositions.CholeskyDecompositionTest;
+import org.apache.ignite.math.decompositions.EigenDecompositionTest;
+import org.apache.ignite.math.decompositions.LUDecompositionTest;
+import org.apache.ignite.math.decompositions.QRDecompositionTest;
+import org.apache.ignite.math.decompositions.SingularValueDecompositionTest;
+import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrixConstructorTest;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrixConstructorTest;
+import org.apache.ignite.math.impls.matrix.DiagonalMatrixTest;
+import org.apache.ignite.math.impls.matrix.FunctionMatrixConstructorTest;
+import org.apache.ignite.math.impls.matrix.MatrixAttributeTest;
+import org.apache.ignite.math.impls.matrix.MatrixImplementationsTest;
+import org.apache.ignite.math.impls.matrix.MatrixViewConstructorTest;
+import org.apache.ignite.math.impls.matrix.PivotedMatrixViewConstructorTest;
+import org.apache.ignite.math.impls.matrix.RandomMatrixConstructorTest;
+import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrixConstructorTest;
+import org.apache.ignite.math.impls.matrix.TransposedMatrixViewTest;
+import org.apache.ignite.math.impls.storage.matrix.MatrixArrayStorageTest;
+import org.apache.ignite.math.impls.storage.matrix.MatrixOffHeapStorageTest;
+import org.apache.ignite.math.impls.storage.matrix.MatrixStorageImplementationTest;
+import org.apache.ignite.math.impls.storage.vector.RandomAccessSparseVectorStorageTest;
+import org.apache.ignite.math.impls.storage.vector.SparseLocalOffHeapVectorStorageTest;
+import org.apache.ignite.math.impls.storage.vector.VectorArrayStorageTest;
+import org.apache.ignite.math.impls.storage.vector.VectorOffheapStorageTest;
+import org.apache.ignite.math.impls.vector.AbstractVectorTest;
+import org.apache.ignite.math.impls.vector.ConstantVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.DelegatingVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.FunctionVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.MatrixVectorViewTest;
+import org.apache.ignite.math.impls.vector.PivotedVectorViewConstructorTest;
+import org.apache.ignite.math.impls.vector.RandomVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.SingleElementVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.SingleElementVectorViewConstructorTest;
+import org.apache.ignite.math.impls.vector.SparseLocalVectorConstructorTest;
+import org.apache.ignite.math.impls.vector.VectorAttributesTest;
+import org.apache.ignite.math.impls.vector.VectorFoldMapTest;
+import org.apache.ignite.math.impls.vector.VectorImplementationsTest;
+import org.apache.ignite.math.impls.vector.VectorIterableTest;
+import org.apache.ignite.math.impls.vector.VectorNormTest;
+import org.apache.ignite.math.impls.vector.VectorToMatrixTest;
+import org.apache.ignite.math.impls.vector.VectorViewTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Test suite for all local tests located in org.apache.ignite.math.impls.* package.
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ // Vector constructors tests.
+ DenseLocalOnHeapVectorConstructorTest.class,
+ DenseLocalOffHeapVectorConstructorTest.class,
+ SparseLocalVectorConstructorTest.class,
+ RandomVectorConstructorTest.class,
+ ConstantVectorConstructorTest.class,
+ FunctionVectorConstructorTest.class,
+ SingleElementVectorConstructorTest.class,
+ PivotedVectorViewConstructorTest.class,
+ SingleElementVectorViewConstructorTest.class,
+ DelegatingVectorConstructorTest.class,
+ // Various vectors tests.
+ AbstractVectorTest.class,
+ VectorImplementationsTest.class,
+ VectorViewTest.class,
+ MatrixVectorViewTest.class,
+ // Vector particular features tests.
+ VectorIterableTest.class,
+ VectorAttributesTest.class,
+ VectorToMatrixTest.class,
+ VectorNormTest.class,
+ VectorFoldMapTest.class,
+ // Vector storage tests
+ VectorArrayStorageTest.class,
+ VectorOffheapStorageTest.class,
+ RandomAccessSparseVectorStorageTest.class,
+ SparseLocalOffHeapVectorStorageTest.class,
+ // Matrix storage tests.
+ MatrixStorageImplementationTest.class,
+ MatrixOffHeapStorageTest.class,
+ MatrixArrayStorageTest.class,
+ // Matrix constructors tests.
+ DenseLocalOnHeapMatrixConstructorTest.class,
+ DenseLocalOffHeapMatrixConstructorTest.class,
+ RandomMatrixConstructorTest.class,
+ FunctionMatrixConstructorTest.class,
+ MatrixViewConstructorTest.class,
+ PivotedMatrixViewConstructorTest.class,
+ SparseLocalOnHeapMatrixConstructorTest.class,
+ // Matrix tests.
+ MatrixImplementationsTest.class,
+ DiagonalMatrixTest.class,
+ MatrixAttributeTest.class,
+ TransposedMatrixViewTest.class,
+ // Decomposes
+ LUDecompositionTest.class,
+ EigenDecompositionTest.class,
+ CholeskyDecompositionTest.class,
+ QRDecompositionTest.class,
+ SingularValueDecompositionTest.class
+})
+public class MathImplLocalTestSuite {
+ // No-op.
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java b/modules/ml/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java
new file mode 100644
index 0000000..44fa8e6
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java
@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Test suite for local and distributed tests
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ MathImplLocalTestSuite.class,
+ MathImplDistributedTestSuite.class
+})
+public class MathImplMainTestSuite {
+ // No-op.
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/TracerTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/TracerTest.java b/modules/ml/src/test/java/org/apache/ignite/math/TracerTest.java
new file mode 100644
index 0000000..35d2f60
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/TracerTest.java
@@ -0,0 +1,195 @@
+/*
+ * 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;
+
+import java.awt.Color;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+import org.apache.ignite.math.impls.MathTestConstants;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.junit.Test;
+
+import static java.nio.file.Files.createTempFile;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests for {@link Tracer}.
+ */
+public class TracerTest {
+ /** */ private static final String DEFAULT_FORMAT = "%.10f";
+ /** */ private static final double DEFAULT_DELTA = 0.000000001d;
+
+ /**
+ * Color mapper that maps [0, 1] range into three distinct RGB segments.
+ */
+ private static final Tracer.ColorMapper COLOR_MAPPER = new Tracer.ColorMapper() {
+ /** {@inheritDoc} */
+ @Override public Color apply(Double d) {
+ if (d <= 0.33)
+ return Color.RED;
+ else if (d <= 0.66)
+ return Color.GREEN;
+ else
+ return Color.BLUE;
+ }
+ };
+
+ /**
+ * @param size Vector size.
+ */
+ private Vector makeRandomVector(int size) {
+ DenseLocalOnHeapVector vec = new DenseLocalOnHeapVector(size);
+
+ vec.assign((idx) -> Math.random());
+
+ return vec;
+ }
+
+ /**
+ * @param rows Amount of rows in matrix.
+ * @param cols Amount of columns in matrix.
+ */
+ private Matrix makeRandomMatrix(int rows, int cols) {
+ DenseLocalOnHeapMatrix mtx = new DenseLocalOnHeapMatrix(rows, cols);
+
+ // Missing assign(f)?
+ mtx.map((d) -> Math.random());
+
+ return mtx;
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testAsciiVectorTracer() {
+ Vector vec = makeRandomVector(20);
+
+ Tracer.showAscii(vec);
+ Tracer.showAscii(vec, "%2f");
+ Tracer.showAscii(vec, "%.3g");
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testAsciiMatrixTracer() {
+ Matrix mtx = makeRandomMatrix(10, 10);
+
+ Tracer.showAscii(mtx);
+ Tracer.showAscii(mtx, "%2f");
+ Tracer.showAscii(mtx, "%.3g");
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testHtmlVectorTracer() throws IOException {
+ Vector vec1 = makeRandomVector(1000);
+
+ // Default color mapping.
+ Tracer.showHtml(vec1);
+
+ // Custom color mapping.
+ Tracer.showHtml(vec1, COLOR_MAPPER);
+
+ // Default color mapping with sorted vector.
+ Tracer.showHtml(vec1.sort());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testHtmlMatrixTracer() throws IOException {
+ Matrix mtx1 = makeRandomMatrix(100, 100);
+
+ // Custom color mapping.
+ Tracer.showHtml(mtx1, COLOR_MAPPER);
+
+ Matrix mtx2 = new DenseLocalOnHeapMatrix(100, 100);
+
+ double MAX = (double)(mtx2.rowSize() * mtx2.columnSize());
+
+ mtx2.assign((x, y) -> (double)(x * y) / MAX);
+
+ Tracer.showHtml(mtx2);
+ }
+
+ /** */
+ @Test
+ public void testWriteVectorToCSVFile() throws IOException {
+ DenseLocalOnHeapVector vector = new DenseLocalOnHeapVector(MathTestConstants.STORAGE_SIZE);
+
+ for (int i = 0; i < vector.size(); i++)
+ vector.set(i, Math.random());
+
+ Path file = createTempFile("vector", ".csv");
+
+ Tracer.saveAsCsv(vector, DEFAULT_FORMAT, file.toString());
+
+ System.out.println("Vector exported: " + file.getFileName());
+
+ List<String> strings = Files.readAllLines(file);
+ Optional<String> reduce = strings.stream().reduce((s1, s2) -> s1 + s2);
+ String[] csvVals = reduce.get().split(",");
+
+ for (int i = 0; i < vector.size(); i++) {
+ Double csvVal = Double.valueOf(csvVals[i]);
+
+ assertEquals("Unexpected value.", csvVal, vector.get(i), DEFAULT_DELTA);
+ }
+
+ Files.deleteIfExists(file);
+ }
+
+ /** */
+ @Test
+ public void testWriteMatrixToCSVFile() throws IOException {
+ DenseLocalOnHeapMatrix matrix = new DenseLocalOnHeapMatrix(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
+
+ for (int i = 0; i < matrix.rowSize(); i++)
+ for (int j = 0; j < matrix.columnSize(); j++)
+ matrix.set(i, j, Math.random());
+
+ Path file = createTempFile("matrix", ".csv");
+
+ Tracer.saveAsCsv(matrix, DEFAULT_FORMAT, file.toString());
+
+ System.out.println("Matrix exported: " + file.getFileName());
+
+ List<String> strings = Files.readAllLines(file);
+ Optional<String> reduce = strings.stream().reduce((s1, s2) -> s1 + s2);
+ String[] csvVals = reduce.get().split(",");
+
+ for (int i = 0; i < matrix.rowSize(); i++)
+ for (int j = 0; j < matrix.columnSize(); j++) {
+ Double csvVal = Double.valueOf(csvVals[i * matrix.rowSize() + j]);
+
+ assertEquals("Unexpected value.", csvVal, matrix.get(i, j), DEFAULT_DELTA);
+ }
+
+ Files.deleteIfExists(file);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java
new file mode 100644
index 0000000..4c3718a
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmark.java
@@ -0,0 +1,205 @@
+/*
+ * 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.benchmark;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+/** Refer {@link MathBenchmarkSelfTest} for usage examples. */
+class MathBenchmark {
+ /** */
+ private final boolean outputToConsole;
+
+ /** */
+ private final String benchmarkName;
+
+ /** */
+ private final int measurementTimes;
+
+ /** */
+ private final int warmUpTimes;
+
+ /** */
+ private final String tag;
+
+ /** */
+ private final String comments;
+
+ /** Constructor strictly for use within this class. */
+ private MathBenchmark(String benchmarkName, boolean outputToConsole, int measurementTimes, int warmUpTimes,
+ String tag, String comments) {
+ this.benchmarkName = benchmarkName;
+ this.outputToConsole = outputToConsole;
+ this.measurementTimes = measurementTimes;
+ this.warmUpTimes = warmUpTimes;
+ this.tag = tag;
+ this.comments = comments;
+ validate();
+ }
+
+ /**
+ * Benchmark with specified name and default parameters, in particular, default output file.
+ *
+ * @param benchmarkName name
+ */
+ MathBenchmark(String benchmarkName) {
+ this(benchmarkName, false, 100, 1, "", "");
+ }
+
+ /**
+ * Executes the code using config of this benchmark.
+ *
+ * @param code code to execute
+ * @throws Exception if something goes wrong
+ */
+ void execute(BenchmarkCode code) throws Exception {
+ System.out.println("Started benchmark [" + benchmarkName + "].");
+
+ for (int cnt = 0; cnt < warmUpTimes; cnt++)
+ code.call();
+
+ final long start = System.currentTimeMillis();
+
+ for (int cnt = 0; cnt < measurementTimes; cnt++)
+ code.call();
+
+ final long end = System.currentTimeMillis();
+
+ writeResults(formatResults(start, end));
+
+ System.out.println("Finished benchmark [" + benchmarkName + "].");
+ }
+
+ /**
+ * Set optional output mode for using stdout.
+ *
+ * @return configured benchmark
+ */
+ MathBenchmark outputToConsole() {
+ return new MathBenchmark(benchmarkName, true, measurementTimes, warmUpTimes, tag, comments);
+ }
+
+ /**
+ * Set optional measurement times.
+ *
+ * @param param times
+ * @return configured benchmark
+ */
+ MathBenchmark measurementTimes(int param) {
+ return new MathBenchmark(benchmarkName, outputToConsole, param, warmUpTimes, tag, comments);
+ }
+
+ /**
+ * Set optional warm-up times.
+ *
+ * @param param times
+ * @return configured benchmark
+ */
+ MathBenchmark warmUpTimes(int param) {
+ return new MathBenchmark(benchmarkName, outputToConsole, measurementTimes, param, tag, comments);
+ }
+
+ /**
+ * Set optional tag to help filtering specific kind of benchmark results.
+ *
+ * @param param name
+ * @return configured benchmark
+ */
+ MathBenchmark tag(String param) {
+ return new MathBenchmark(benchmarkName, outputToConsole, measurementTimes, warmUpTimes, param, comments);
+ }
+
+ /**
+ * Set optional comments.
+ *
+ * @param param name
+ * @return configured benchmark
+ */
+ MathBenchmark comments(String param) {
+ return new MathBenchmark(benchmarkName, outputToConsole, measurementTimes, warmUpTimes, tag, param);
+ }
+
+ /** */
+ private void writeResults(String results) throws Exception {
+ if (outputToConsole) {
+ System.out.println(results);
+
+ return;
+ }
+
+ new ResultsWriter().append(results);
+ }
+
+ /** */
+ private String formatResults(long start, long end) {
+ final String delim = ",";
+
+ assert !formatDouble(1000_000_001.1).contains(delim) : "Formatted results contain [" + delim + "].";
+
+ final String ts = formatTs(start);
+
+ assert !ts.contains(delim) : "Formatted timestamp contains [" + delim + "].";
+
+ return benchmarkName +
+ delim +
+ ts + // IMPL NOTE timestamp
+ delim +
+ formatDouble((double)(end - start) / measurementTimes) +
+ delim +
+ measurementTimes +
+ delim +
+ warmUpTimes +
+ delim +
+ tag +
+ delim +
+ comments;
+ }
+
+ /** */
+ private String formatDouble(double val) {
+ return String.format(Locale.US, "%f", val);
+ }
+
+ /** */
+ private String formatTs(long ts) {
+ final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");
+
+ sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
+
+ return sdf.format(new Date(ts));
+ }
+
+ /** */
+ private void validate() {
+ if (benchmarkName == null || benchmarkName.isEmpty())
+ throw new IllegalArgumentException("Invalid benchmark name: [" + benchmarkName + "].");
+
+ if (measurementTimes < 1)
+ throw new IllegalArgumentException("Invalid measurement times: [" + measurementTimes + "].");
+ }
+
+ /** */
+ interface BenchmarkCode {
+ // todo find out why Callable<Void> failed to work here
+
+ /** */
+ void call() throws Exception;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java
new file mode 100644
index 0000000..7a86461
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/MathBenchmarkSelfTest.java
@@ -0,0 +1,100 @@
+/*
+ * 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.benchmark;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class MathBenchmarkSelfTest {
+ /** */
+ @Test
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void demoTest() throws Exception {
+ for (int i = 0; i < 2; i++)
+ new MathBenchmark("demo test")
+ .outputToConsole() // IMPL NOTE this is to write output into console instead of a file
+ .tag(null) // IMPL NOTE try null for tag, expect it to be formatted reasonably
+ .comments(null) // IMPL NOTE try null for comments, expect it to be formatted reasonably
+ .execute(() -> {
+ double seed = 1.1;
+
+ for (int cnt = 0; cnt < 1000; cnt++) {
+ seed = Math.pow(seed, 2);
+
+ assertTrue(seed > 0);
+ }
+ });
+ }
+
+ /** */
+ @Test
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void configTest() throws Exception {
+ new MathBenchmark("demo config test")
+ .outputToConsole()
+ .measurementTimes(2)
+ .warmUpTimes(0)
+ .tag("demo tag")
+ .comments("demo comments")
+ .execute(() -> System.out.println("config test"));
+ }
+
+ /** */
+ @Test(expected = IllegalArgumentException.class)
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void emptyNameTest() throws Exception {
+ new MathBenchmark("")
+ .outputToConsole()
+ .measurementTimes(1)
+ .warmUpTimes(1)
+ .tag("empty name test tag")
+ .comments("empty name test comments")
+ .execute(() -> System.out.println("empty name test"));
+ }
+
+ /** */
+ @Test(expected = IllegalArgumentException.class)
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void nullDropboxPathTest() throws Exception {
+ new ResultsWriter(null, "whatever", "whatever");
+ }
+
+ /** */
+ @Test(expected = IllegalArgumentException.class)
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void nullDropboxUrlTest() throws Exception {
+ new ResultsWriter("whatever", null, "whatever");
+ }
+
+ /** */
+ @Test(expected = IllegalArgumentException.class)
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void nullDropboxTokenTest() throws Exception {
+ new ResultsWriter("whatever", "whatever", null);
+ }
+
+ /** */
+ @Test(expected = IllegalArgumentException.class)
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void nullResultsTest() throws Exception {
+ new ResultsWriter("whatever", "whatever", "whatever").append(null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java
new file mode 100644
index 0000000..aeec156
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/ResultsWriter.java
@@ -0,0 +1,127 @@
+/*
+ * 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.benchmark;
+
+import com.dropbox.core.DbxException;
+import com.dropbox.core.DbxRequestConfig;
+import com.dropbox.core.v2.DbxClientV2;
+import com.dropbox.core.v2.files.WriteMode;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.UUID;
+
+/** */
+class ResultsWriter {
+ /** */
+ private static final String DROPBOX_PATH
+ = "/benchmarks/math.benchmark.results.csv";
+
+ /** */
+ private static final String DROPBOX_URL
+ = "https://www.dropbox.com/s/r7tcle31r7gaty8/math.benchmark.results.csv";
+
+ /** */
+ private static final String ACCESS_TOKEN
+ = "1MMmQjEyzGAAAAAAAAAAfDFrQ6oBPPi4NX-iU_VrgmXB2JDXqRHGa125cTkkEQ0V";
+
+ /** */
+ private final String dropboxPath;
+ /** */
+ private final String dropboxUrl;
+ /** */
+ private final String accessTok;
+
+ /** */
+ ResultsWriter(String dropboxPath, String dropboxUrl, String accessTok) {
+ this.dropboxPath = dropboxPath;
+ this.dropboxUrl = dropboxUrl;
+ this.accessTok = accessTok;
+
+ if (dropboxPath == null || dropboxUrl == null || accessTok == null)
+ throw new IllegalArgumentException("Neither of dropbox path, URL, access token can be null.");
+ }
+
+ /** **/
+ ResultsWriter() {
+ this(DROPBOX_PATH, DROPBOX_URL, ACCESS_TOKEN);
+ }
+
+ /** */
+ void append(String res) throws DbxException, IOException {
+ if (res == null)
+ throw new IllegalArgumentException("benchmark result is null");
+
+ if (dropboxPath == null) {
+ System.out.println(res);
+
+ return;
+ }
+
+ append(res, client());
+ }
+
+ /** */
+ private void append(String res, DbxClientV2 client) throws DbxException, IOException {
+ File tmp = createTmpFile();
+
+ try (FileOutputStream out = new FileOutputStream(tmp)) {
+ client.files().download(dropboxPath).download(out);
+ }
+
+ writeResults(res, tmp);
+
+ try (FileInputStream in = new FileInputStream(tmp)) {
+ client.files().uploadBuilder(dropboxPath).withMode(WriteMode.OVERWRITE).uploadAndFinish(in);
+ }
+
+ if (!tmp.delete())
+ System.out.println("Failed to delete " + tmp.getAbsolutePath());
+
+ System.out.println("Uploaded benchmark results to: " + dropboxUrl);
+ }
+
+ /** */
+ private void writeResults(String res, File tmp) throws IOException {
+ final String unixLineSeparator = "\n";
+
+ try (final PrintWriter writer = new PrintWriter(Files.newBufferedWriter(Paths.get(tmp.toURI()),
+ StandardOpenOption.APPEND, StandardOpenOption.CREATE))) {
+ writer.write(res + unixLineSeparator);
+ }
+ }
+
+ /** */
+ private File createTmpFile() throws IOException {
+ File tmp = File.createTempFile(UUID.randomUUID().toString(), ".csv");
+
+ tmp.deleteOnExit();
+
+ return tmp;
+ }
+
+ /** */
+ private DbxClientV2 client() {
+ return new DbxClientV2(DbxRequestConfig.newBuilder("dropbox/MathBenchmark").build(), accessTok);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java
new file mode 100644
index 0000000..1f7b204
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/VectorBenchmarkTest.java
@@ -0,0 +1,138 @@
+/*
+ * 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.benchmark;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+
+/** */
+public class VectorBenchmarkTest {
+ // todo add benchmarks for other methods in Vector and for other types of Vector and Matrix
+
+ /** */
+ @Test
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void testDenseLocalOnHeapVector() throws Exception {
+ benchmark("DenseLocalOnHeapVector basic mix", DenseLocalOnHeapVector::new, this::basicMix);
+
+ benchmark("DenseLocalOnHeapVector fold map", DenseLocalOnHeapVector::new, this::foldMapMix);
+ }
+
+ /** */
+ @Test
+ @Ignore("Benchmark tests are intended only for manual execution")
+ public void testDenseLocalOffHeapVector() throws Exception {
+ benchmark("DenseLocalOffHeapVector basic mix", DenseLocalOffHeapVector::new, this::basicMix);
+
+ benchmark("DenseLocalOffHeapVector fold map", DenseLocalOffHeapVector::new, this::foldMapMix);
+ }
+
+ /** */
+ private void benchmark(String namePrefix, Function<Integer, Vector> constructor,
+ BiConsumer<Integer, Function<Integer, Vector>> consumer) throws Exception {
+ assertNotNull(namePrefix);
+
+ new MathBenchmark(namePrefix + " small sizes").execute(() -> {
+ for (int size : new int[] {2, 3, 4, 5, 6, 7})
+ consumer.accept(size, constructor);
+ });
+
+ new MathBenchmark(namePrefix + " sizes powers of 2").execute(() -> {
+ for (int power : new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14})
+ consumer.accept(1 << power, constructor);
+ });
+
+ new MathBenchmark(namePrefix + " large sizes").execute(() -> {
+ for (int power : new int[] {10, 12, 14, 16})
+ for (int delta : new int[] {-1, 0, 1})
+ consumer.accept((1 << power) + delta, constructor);
+ });
+
+ new MathBenchmark(namePrefix + " extra large sizes")
+ .measurementTimes(10)
+ .execute(() -> { // IMPL NOTE trying below with power 22 almost killed my IDEA and laptop
+ for (int power : new int[] {17, 18, 19, 20, 21})
+ for (int delta : new int[] {-1, 0}) // IMPL NOTE delta +1 is not intended for use here
+ consumer.accept((1 << power) + delta, constructor);
+ });
+ }
+
+ /** */
+ private void basicMix(int size, Function<Integer, Vector> constructor) {
+ final Vector v1 = constructor.apply(size), v2 = constructor.apply(size);
+
+ for (int idx = 0; idx < size; idx++) {
+ v1.set(idx, idx);
+
+ v2.set(idx, size - idx);
+ }
+
+ assertNotNull(v1.sum());
+
+ assertNotNull(v1.copy());
+
+ assertFalse(v1.getLengthSquared() < 0);
+
+ assertNotNull(v1.normalize());
+
+ assertNotNull(v1.logNormalize());
+
+ assertFalse(v1.getDistanceSquared(v2) < 0);
+
+ assertNotNull(v1.divide(2));
+
+ assertNotNull(v1.minus(v2));
+
+ assertNotNull(v1.plus(v2));
+
+ assertNotNull(v1.dot(v2));
+
+ assertNotNull(v1.assign(v2));
+
+ assertNotNull(v1.assign(1)); // IMPL NOTE this would better be last test for it sets all values the same
+ }
+
+ /** */
+ private void foldMapMix(int size, Function<Integer, Vector> constructor) {
+ final Vector v1 = constructor.apply(size), v2 = constructor.apply(size);
+
+ for (int idx = 0; idx < size; idx++) {
+ v1.set(idx, idx);
+
+ v2.set(idx, size - idx);
+ }
+
+ assertNotNull(v1.map((val) -> (val + 1)));
+
+ assertNotNull(v1.map(v2, (one, other) -> one + other / 2.0));
+
+ assertNotNull(v1.map((val, val1) -> (val + val1), 2.0));
+
+ assertNotNull(v1.foldMap((sum, val) -> (val + sum), (val) -> val, 0.0));
+
+ assertNotNull(v1.foldMap(v2, (sum, val) -> (val + sum), (val1, val2) -> val1 + val2, 0.0));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/benchmark/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/benchmark/package-info.java b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/package-info.java
new file mode 100644
index 0000000..cbf5d36
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/benchmark/package-info.java
@@ -0,0 +1,18 @@
+/*
+ * 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.benchmark;
[15/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java
deleted file mode 100644
index 8218a12..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrixTest.java
+++ /dev/null
@@ -1,265 +0,0 @@
-// @java.file.header
-
-/* _________ _____ __________________ _____
- * __ ____/___________(_)______ /__ ____/______ ____(_)_______
- * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
- * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
- * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
- */
-
-/*
- * 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.matrix;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import org.apache.ignite.Ignite;
-import org.apache.ignite.internal.util.IgniteUtils;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
-import org.apache.ignite.testframework.junits.common.GridCommonTest;
-
-import static org.apache.ignite.math.impls.MathTestConstants.UNEXPECTED_VAL;
-
-/**
- * Tests for {@link SparseDistributedMatrix}.
- */
-@GridCommonTest(group = "Distributed Models")
-public class SparseDistributedMatrixTest extends GridCommonAbstractTest {
- /** Number of nodes in grid */
- private static final int NODE_COUNT = 3;
- /** Cache name. */
- private static final String CACHE_NAME = "test-cache";
- /** Precision. */
- private static final double PRECISION = 0.0;
- /** Grid instance. */
- private Ignite ignite;
- /** Matrix rows */
- private final int rows = MathTestConstants.STORAGE_SIZE;
- /** Matrix cols */
- private final int cols = MathTestConstants.STORAGE_SIZE;
- /** Matrix for tests */
- private SparseDistributedMatrix cacheMatrix;
-
- /**
- * Default constructor.
- */
- public SparseDistributedMatrixTest() {
- super(false);
- }
-
- /** {@inheritDoc} */
- @Override protected void beforeTestsStarted() throws Exception {
- for (int i = 1; i <= NODE_COUNT; i++)
- startGrid(i);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTestsStopped() throws Exception {
- stopAllGrids();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override protected void beforeTest() throws Exception {
- ignite = grid(NODE_COUNT);
-
- ignite.configuration().setPeerClassLoadingEnabled(true);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTest() throws Exception {
- ignite.destroyCache(CACHE_NAME);
-
- if (cacheMatrix != null) {
- cacheMatrix.destroy();
- cacheMatrix = null;
- }
- }
-
- /** */
- public void testGetSet() throws Exception {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- for (int i = 0; i < rows; i++) {
- for (int j = 0; j < cols; j++) {
- double v = Math.random();
- cacheMatrix.set(i, j, v);
-
- assert Double.compare(v, cacheMatrix.get(i, j)) == 0;
- }
- }
- }
-
- /** */
- public void testExternalize() throws IOException, ClassNotFoundException {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- cacheMatrix.set(1, 1, 1.0);
-
- ByteArrayOutputStream byteArrOutputStream = new ByteArrayOutputStream();
- ObjectOutputStream objOutputStream = new ObjectOutputStream(byteArrOutputStream);
-
- objOutputStream.writeObject(cacheMatrix);
-
- ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(byteArrOutputStream.toByteArray());
- ObjectInputStream objInputStream = new ObjectInputStream(byteArrInputStream);
-
- SparseDistributedMatrix objRestored = (SparseDistributedMatrix)objInputStream.readObject();
-
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, cacheMatrix.equals(objRestored));
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, objRestored.get(1, 1), 1.0, 0.0);
- }
-
- /** Test simple math. */
- public void testMath() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
- initMtx(cacheMatrix);
-
- cacheMatrix.assign(2.0);
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- assertEquals(UNEXPECTED_VAL, 2.0, cacheMatrix.get(i, j), PRECISION);
-
- cacheMatrix.plus(3.0);
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- assertEquals(UNEXPECTED_VAL, 5.0, cacheMatrix.get(i, j), PRECISION);
-
- cacheMatrix.times(2.0);
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- assertEquals(UNEXPECTED_VAL, 10.0, cacheMatrix.get(i, j), PRECISION);
-
- cacheMatrix.divide(10.0);
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- assertEquals(UNEXPECTED_VAL, 1.0, cacheMatrix.get(i, j), PRECISION);
-
- assertEquals(UNEXPECTED_VAL, cacheMatrix.rowSize() * cacheMatrix.columnSize(), cacheMatrix.sum(), PRECISION);
- }
-
- /** */
- public void testMinMax() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- cacheMatrix.set(i, j, i * cols + j + 1);
-
- assertEquals(UNEXPECTED_VAL, 1.0, cacheMatrix.minValue(), PRECISION);
- assertEquals(UNEXPECTED_VAL, rows * cols, cacheMatrix.maxValue(), PRECISION);
-
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- cacheMatrix.set(i, j, -1.0 * (i * cols + j + 1));
-
- assertEquals(UNEXPECTED_VAL, -rows * cols, cacheMatrix.minValue(), PRECISION);
- assertEquals(UNEXPECTED_VAL, -1.0, cacheMatrix.maxValue(), PRECISION);
-
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- cacheMatrix.set(i, j, i * cols + j);
-
- assertEquals(UNEXPECTED_VAL, 1.0, cacheMatrix.minValue(), PRECISION);
- assertEquals(UNEXPECTED_VAL, rows * cols - 1.0, cacheMatrix.maxValue(), PRECISION);
- }
-
- /** */
- public void testMap() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
- initMtx(cacheMatrix);
-
- cacheMatrix.map(i -> 100.0);
- for (int i = 0; i < cacheMatrix.rowSize(); i++)
- for (int j = 0; j < cacheMatrix.columnSize(); j++)
- assertEquals(UNEXPECTED_VAL, 100.0, cacheMatrix.get(i, j), PRECISION);
- }
-
- /** */
- public void testCopy() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- try {
- cacheMatrix.copy();
- fail("UnsupportedOperationException expected.");
- }
- catch (UnsupportedOperationException e) {
- return;
- }
- fail("UnsupportedOperationException expected.");
- }
-
- /** */
- public void testLike() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- try {
- cacheMatrix.like(1, 1);
- fail("UnsupportedOperationException expected.");
- }
- catch (UnsupportedOperationException e) {
- return;
- }
- fail("UnsupportedOperationException expected.");
- }
-
- /** */
- public void testLikeVector() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- cacheMatrix = new SparseDistributedMatrix(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- try {
- cacheMatrix.likeVector(1);
- fail("UnsupportedOperationException expected.");
- }
- catch (UnsupportedOperationException e) {
- return;
- }
- fail("UnsupportedOperationException expected.");
- }
-
- /** */
- private void initMtx(Matrix m) {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- m.set(i, j, 1.0);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java
deleted file mode 100644
index fc675c1..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrixConstructorTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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.matrix;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class SparseLocalOnHeapMatrixConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new SparseLocalOnHeapMatrix(0, 1),
- "invalid row parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new SparseLocalOnHeapMatrix(1, 0),
- "invalid col parameter");
- }
-
- /** */
- @Test
- public void basicTest() {
- assertEquals("Expected number of rows.", 1,
- new SparseLocalOnHeapMatrix(1, 2).rowSize());
-
- assertEquals("Expected number of cols, int parameters.", 1,
- new SparseLocalOnHeapMatrix(2, 1).columnSize());
-
- SparseLocalOnHeapMatrix m = new SparseLocalOnHeapMatrix(1, 1);
- //noinspection EqualsWithItself
- assertTrue("Matrix is expected to be equal to self.", m.equals(m));
- //noinspection ObjectEqualsNull
- assertFalse("Matrix is expected to be not equal to null.", m.equals(null));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java
deleted file mode 100644
index 5eacfea..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/TransposedMatrixViewTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/**
- * Tests for {@link TransposedMatrixView}.
- */
-public class TransposedMatrixViewTest extends ExternalizeTest<TransposedMatrixView> {
- /** */
- private static final String UNEXPECTED_VALUE = "Unexpected value";
- /** */
- private TransposedMatrixView testMatrix;
- /** */
- private DenseLocalOnHeapMatrix parent;
-
- /** */
- @Before
- public void setup() {
- parent = new DenseLocalOnHeapMatrix(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
- fillMatrix(parent);
- testMatrix = new TransposedMatrixView(parent);
- }
-
- /** {@inheritDoc} */
- @Override public void externalizeTest() {
- externalizeTest(testMatrix);
- }
-
- /** */
- @Test
- public void testView() {
- assertEquals(UNEXPECTED_VALUE, parent.rowSize(), testMatrix.columnSize());
- assertEquals(UNEXPECTED_VALUE, parent.columnSize(), testMatrix.rowSize());
-
- for (int i = 0; i < parent.rowSize(); i++)
- for (int j = 0; j < parent.columnSize(); j++)
- assertEquals(UNEXPECTED_VALUE, parent.get(i, j), testMatrix.get(j, i), 0d);
- }
-
- /** */
- @Test
- public void testNullParams() {
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new TransposedMatrixView(null), "Null Matrix parameter");
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void testLike() {
- testMatrix.like(0, 0);
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void testLikeVector() {
- testMatrix.likeVector(0);
- }
-
- /** */
- private void fillMatrix(DenseLocalOnHeapMatrix mtx) {
- for (int i = 0; i < mtx.rowSize(); i++)
- for (int j = 0; j < mtx.columnSize(); j++)
- mtx.setX(i, j, i * mtx.rowSize() + j);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java
deleted file mode 100644
index 817dd49..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixArrayStorageTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Test;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Unit tests for {@link ArrayMatrixStorage}.
- */
-public class MatrixArrayStorageTest extends MatrixBaseStorageTest<ArrayMatrixStorage> {
- /** {@inheritDoc} */
- @Override public void setUp() {
- storage = new ArrayMatrixStorage(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void isSequentialAccess() throws Exception {
- assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isSequentialAccess());
- }
-
- /** */
- @Test
- public void isDense() throws Exception {
- assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isDense());
- }
-
- /** */
- @Test
- public void isArrayBased() throws Exception {
- assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isArrayBased());
- }
-
- /** */
- @Test
- public void data() throws Exception {
- double[][] data = storage.data();
- assertNotNull(MathTestConstants.NULL_VAL, data);
- assertTrue(MathTestConstants.UNEXPECTED_VAL, data.length == MathTestConstants.STORAGE_SIZE);
- assertTrue(MathTestConstants.UNEXPECTED_VAL, data[0].length == MathTestConstants.STORAGE_SIZE);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java
deleted file mode 100644
index 8df19e4..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixBaseStorageTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/**
- * Abstract class with base tests for each matrix storage.
- */
-public abstract class MatrixBaseStorageTest<T extends MatrixStorage> extends ExternalizeTest<T> {
- /** */
- protected T storage;
-
- /** */
- @Before
- public abstract void setUp();
-
- /** */
- @After
- public void tearDown() throws Exception {
- storage.destroy();
- }
-
- /** */
- @Test
- public void getSet() throws Exception {
- int rows = MathTestConstants.STORAGE_SIZE;
- int cols = MathTestConstants.STORAGE_SIZE;
-
- for (int i = 0; i < rows; i++) {
- for (int j = 0; j < cols; j++) {
- double data = Math.random();
-
- storage.set(i, j, data);
-
- Assert.assertEquals(MathTestConstants.VAL_NOT_EQUALS, storage.get(i, j), data, MathTestConstants.NIL_DELTA);
- }
- }
- }
-
- /** */
- @Test
- public void columnSize() throws Exception {
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, storage.columnSize(), MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void rowSize() throws Exception {
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, storage.rowSize(), MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Override public void externalizeTest() {
- fillMatrix();
- super.externalizeTest(storage);
- }
-
- /** */
- protected void fillMatrix() {
- for (int i = 0; i < storage.rowSize(); i++) {
- for (int j = 0; j < storage.columnSize(); j++)
- storage.set(i, j, Math.random());
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java
deleted file mode 100644
index a3b21bb..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixOffHeapStorageTest.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Test;
-
-import static org.junit.Assert.assertNull;
-
-/**
- * Unit tests for {@link DenseOffHeapMatrixStorage}.
- */
-public class MatrixOffHeapStorageTest extends MatrixBaseStorageTest<DenseOffHeapMatrixStorage> {
- /** {@inheritDoc} */
- @Override public void setUp() {
- storage = new DenseOffHeapMatrixStorage(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void data() throws Exception {
- assertNull(MathTestConstants.UNEXPECTED_VAL, storage.data());
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java
deleted file mode 100644
index 6353c38..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageFixtures.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.function.BiConsumer;
-import java.util.function.Supplier;
-import org.apache.ignite.math.MatrixStorage;
-import org.jetbrains.annotations.NotNull;
-
-import static org.apache.ignite.math.StorageConstants.COLUMN_STORAGE_MODE;
-import static org.apache.ignite.math.StorageConstants.RANDOM_ACCESS_MODE;
-import static org.apache.ignite.math.StorageConstants.ROW_STORAGE_MODE;
-import static org.apache.ignite.math.StorageConstants.SEQUENTIAL_ACCESS_MODE;
-
-/**
- *
- */
-class MatrixStorageFixtures {
- /** */
- private static final List<Supplier<Iterable<MatrixStorage>>> suppliers = Collections.singletonList(
- (Supplier<Iterable<MatrixStorage>>) SparseLocalMatrixStorageFixture::new
- );
-
- /** */
- void consumeSampleStorages(BiConsumer<Integer, Integer> paramsConsumer,
- BiConsumer<MatrixStorage, String> consumer) {
- for (Supplier<Iterable<MatrixStorage>> fixtureSupplier : suppliers) {
- final Iterable<MatrixStorage> fixture = fixtureSupplier.get();
-
- for (MatrixStorage matrixStorage : fixture) {
- if (paramsConsumer != null)
- paramsConsumer.accept(matrixStorage.rowSize(), matrixStorage.columnSize());
-
- consumer.accept(matrixStorage, fixture.toString());
- }
- }
- }
-
- /** */
- private static class SparseLocalMatrixStorageFixture implements Iterable<MatrixStorage> {
- /** */
- private final Integer[] rows = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 1024, null};
- /** */
- private final Integer[] cols = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 1024, 512, null};
- /** */
- private final Integer[] randomAccess = new Integer[] {SEQUENTIAL_ACCESS_MODE, RANDOM_ACCESS_MODE, null};
- /** */
- private final Integer[] rowStorage = new Integer[] {ROW_STORAGE_MODE, COLUMN_STORAGE_MODE, null};
- /** */
- private int sizeIdx = 0;
- /** */
- private int acsModeIdx = 0;
- /** */
- private int stoModeIdx = 0;
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<MatrixStorage> iterator() {
- return new Iterator<MatrixStorage>() {
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return hasNextCol(sizeIdx) && hasNextRow(sizeIdx)
- && hasNextAcsMode(acsModeIdx) && hasNextStoMode(stoModeIdx);
- }
-
- /** {@inheritDoc} */
- @Override public MatrixStorage next() {
- if (!hasNext())
- throw new NoSuchElementException(SparseLocalMatrixStorageFixture.this.toString());
-
- MatrixStorage storage = new SparseLocalOnHeapMatrixStorage(
- rows[sizeIdx], cols[sizeIdx], randomAccess[acsModeIdx], rowStorage[stoModeIdx]);
-
- nextIdx();
-
- return storage;
- }
-
- private void nextIdx() {
- if (hasNextStoMode(stoModeIdx + 1)) {
- stoModeIdx++;
-
- return;
- }
-
- stoModeIdx = 0;
-
- if (hasNextAcsMode(acsModeIdx + 1)) {
- acsModeIdx++;
-
- return;
- }
-
- acsModeIdx = 0;
- sizeIdx++;
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- return "SparseLocalMatrixStorageFixture{ " + "rows=" + rows[sizeIdx] + ", cols=" + cols[sizeIdx] +
- ", access mode=" + randomAccess[acsModeIdx] + ", storage mode=" + rowStorage[stoModeIdx] + "}";
- }
-
- /** */ private boolean hasNextRow(int idx) {
- return rows[idx] != null;
- }
-
- /** */ private boolean hasNextCol(int idx) {
- return cols[idx] != null;
- }
-
- /** */ private boolean hasNextAcsMode(int idx) {
- return randomAccess[idx] != null;
- }
-
- /** */ private boolean hasNextStoMode(int idx) {
- return rowStorage[idx] != null;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java
deleted file mode 100644
index 6ec09bd..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/MatrixStorageImplementationTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.BiConsumer;
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.MatrixStorage;
-import org.junit.Test;
-
-import static org.junit.Assert.assertTrue;
-
-/**
- * Unit tests for {@link MatrixStorage} implementations.
- *
- * TODO: add attribute tests.
- */
-public class MatrixStorageImplementationTest extends ExternalizeTest<MatrixStorage> {
- /**
- * The columnSize() and the rowSize() test.
- */
- @Test
- public void sizeTest() {
- final AtomicReference<Integer> expRowSize = new AtomicReference<>(0);
- final AtomicReference<Integer> expColSize = new AtomicReference<>(0);
-
- consumeSampleStorages((x, y) -> {
- expRowSize.set(x);
- expColSize.set(y);
- },
- (ms, desc) -> assertTrue("Expected size for " + desc, expColSize.get().equals(ms.columnSize()) && expRowSize.get().equals(ms.rowSize())));
- }
-
- /** */
- @Test
- public void getSetTest() {
- consumeSampleStorages(null, (ms, desc) -> {
- for (int i = 0; i < ms.rowSize(); i++) {
- for (int j = 0; j < ms.columnSize(); j++) {
- double random = Math.random();
- ms.set(i, j, random);
- assertTrue("Unexpected value for " + desc + " x:" + i + ", y:" + j, Double.compare(random, ms.get(i, j)) == 0);
- }
- }
- });
- }
-
- /** */
- @Override public void externalizeTest() {
- consumeSampleStorages(null, (ms, desc) -> externalizeTest(ms));
- }
-
- /** */
- private void consumeSampleStorages(BiConsumer<Integer, Integer> paramsConsumer,
- BiConsumer<MatrixStorage, String> consumer) {
- new MatrixStorageFixtures().consumeSampleStorages(paramsConsumer, consumer);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java
deleted file mode 100644
index 66fe9b4..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorageTest.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import org.apache.ignite.Ignite;
-import org.apache.ignite.internal.util.IgniteUtils;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
-import org.apache.ignite.testframework.junits.common.GridCommonTest;
-
-/**
- * Tests for {@link SparseDistributedMatrixStorage}.
- */
-@GridCommonTest(group = "Distributed Models")
-public class SparseDistributedMatrixStorageTest extends GridCommonAbstractTest {
- /** Number of nodes in grid */
- private static final int NODE_COUNT = 3;
- /** Cache name. */
- private static final String CACHE_NAME = "test-cache";
- /** */
- private static final String UNEXPECTED_ATTRIBUTE_VALUE = "Unexpected attribute value.";
- /** Grid instance. */
- private Ignite ignite;
-
- /**
- * Default constructor.
- */
- public SparseDistributedMatrixStorageTest() {
- super(false);
- }
-
- /** {@inheritDoc} */
- @Override protected void beforeTestsStarted() throws Exception {
- for (int i = 1; i <= NODE_COUNT; i++)
- startGrid(i);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTestsStopped() throws Exception {
- stopAllGrids();
- }
-
- /**
- * {@inheritDoc}
- */
- @Override protected void beforeTest() throws Exception {
- ignite = grid(NODE_COUNT);
-
- ignite.configuration().setPeerClassLoadingEnabled(true);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTest() throws Exception {
- ignite.destroyCache(CACHE_NAME);
- }
-
- /** */
- public void testCacheCreation() throws Exception {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- final int rows = MathTestConstants.STORAGE_SIZE;
- final int cols = MathTestConstants.STORAGE_SIZE;
-
- SparseDistributedMatrixStorage storage = new SparseDistributedMatrixStorage(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- assertNotNull("SparseDistributedMatrixStorage cache is null.", storage.cache());
- }
-
- /** */
- public void testSetGet() throws Exception {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- final int rows = MathTestConstants.STORAGE_SIZE;
- final int cols = MathTestConstants.STORAGE_SIZE;
-
- SparseDistributedMatrixStorage storage = new SparseDistributedMatrixStorage(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- for (int i = 0; i < rows; i++) {
- for (int j = 0; j < cols; j++) {
- double v = Math.random();
- storage.set(i, j, v);
-
- assert Double.compare(v, storage.get(i, j)) == 0;
- assert Double.compare(v, storage.get(i, j)) == 0;
- }
- }
- }
-
- /** */
- public void testAttributes() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- final int rows = MathTestConstants.STORAGE_SIZE;
- final int cols = MathTestConstants.STORAGE_SIZE;
-
- SparseDistributedMatrixStorage storage = new SparseDistributedMatrixStorage(rows, cols, StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
-
- assertEquals(UNEXPECTED_ATTRIBUTE_VALUE, storage.rowSize(), rows);
- assertEquals(UNEXPECTED_ATTRIBUTE_VALUE, storage.columnSize(), cols);
-
- assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, storage.isArrayBased());
- assertFalse(UNEXPECTED_ATTRIBUTE_VALUE, storage.isDense());
- assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, storage.isDistributed());
-
- assertEquals(UNEXPECTED_ATTRIBUTE_VALUE, storage.isRandomAccess(), !storage.isSequentialAccess());
- assertTrue(UNEXPECTED_ATTRIBUTE_VALUE, storage.isRandomAccess());
-
- }
-
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java
deleted file mode 100644
index 8a223fc..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/RandomAccessSparseVectorStorageTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * 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.storage.vector;
-
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Test;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-
-/**
- * Unit tests for {@link SparseLocalOnHeapVectorStorage}.
- */
-public class RandomAccessSparseVectorStorageTest extends VectorBaseStorageTest<SparseLocalOnHeapVectorStorage> {
- /** */
- @Override public void setUp() {
- storage = new SparseLocalOnHeapVectorStorage(MathTestConstants.STORAGE_SIZE, StorageConstants.RANDOM_ACCESS_MODE);
- }
-
- /** */
- @Test
- public void data() throws Exception {
- assertNull(MathTestConstants.NULL_VAL, storage.data());
- }
-
- /** */
- @Test
- public void isSequentialAccess() throws Exception {
- assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isSequentialAccess());
- }
-
- /** */
- @Test
- public void isDense() throws Exception {
- assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isDense());
- }
-
- /** */
- @Test
- public void isArrayBased() throws Exception {
- assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isArrayBased());
- }
-
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java
deleted file mode 100644
index a7751d8..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorageTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * 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.storage.vector;
-
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.apache.ignite.math.impls.MathTestConstants.STORAGE_SIZE;
-import static org.apache.ignite.math.impls.MathTestConstants.UNEXPECTED_VAL;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Tests for {@link SparseLocalOffHeapVectorStorage}.
- */
-public class SparseLocalOffHeapVectorStorageTest extends ExternalizeTest<SparseLocalOffHeapVectorStorage> {
- /** */ private SparseLocalOffHeapVectorStorage testVectorStorage;
-
- /** */
- @Before
- public void setup() {
- testVectorStorage = new SparseLocalOffHeapVectorStorage(STORAGE_SIZE);
- }
-
- /** */
- @After
- public void teardown() {
- testVectorStorage.destroy();
- testVectorStorage = null;
- }
-
- /** */
- @Test
- public void testBasic() {
- for (int i = 0; i < STORAGE_SIZE; i++) {
- double testVal = Math.random();
- testVectorStorage.set(i, testVal);
- assertEquals(UNEXPECTED_VAL, testVal, testVectorStorage.get(i), 0d);
- }
- }
-
- /** {@inheritDoc} */
- @Test(expected = UnsupportedOperationException.class)
- @Override public void externalizeTest() {
- super.externalizeTest(new SparseLocalOffHeapVectorStorage(STORAGE_SIZE));
- }
-
- /** */
- @Test
- public void testAttributes() {
- SparseLocalOffHeapVectorStorage testVectorStorage = new SparseLocalOffHeapVectorStorage(STORAGE_SIZE);
-
- assertTrue(UNEXPECTED_VAL, testVectorStorage.isRandomAccess());
- assertFalse(UNEXPECTED_VAL, testVectorStorage.isSequentialAccess());
- assertFalse(UNEXPECTED_VAL, testVectorStorage.isDense());
- assertFalse(UNEXPECTED_VAL, testVectorStorage.isArrayBased());
- assertFalse(UNEXPECTED_VAL, testVectorStorage.isDistributed());
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java
deleted file mode 100644
index 2afc97b..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorArrayStorageTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.util.Arrays;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Unit test for {@link ArrayVectorStorage}.
- */
-public class VectorArrayStorageTest extends VectorBaseStorageTest<ArrayVectorStorage> {
- /** */
- @Override public void setUp() {
- storage = new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void isArrayBased() throws Exception {
- assertTrue(MathTestConstants.WRONG_ATTRIBUTE_VAL, storage.isArrayBased());
-
- assertTrue(MathTestConstants.WRONG_ATTRIBUTE_VAL, new ArrayVectorStorage().isArrayBased());
- }
-
- /** */
- @Test
- public void data() throws Exception {
- assertNotNull(MathTestConstants.NULL_DATA_STORAGE, storage.data());
-
- assertEquals(MathTestConstants.WRONG_DATA_SIZE, storage.data().length, MathTestConstants.STORAGE_SIZE);
-
- assertTrue(MathTestConstants.UNEXPECTED_DATA_VAL, Arrays.equals(storage.data(), new double[MathTestConstants.STORAGE_SIZE]));
-
- assertNull(MathTestConstants.UNEXPECTED_DATA_VAL, new ArrayVectorStorage().data());
- }
-
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java
deleted file mode 100644
index 988f8c3..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorBaseStorageTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * 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.storage.vector;
-
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Abstract class with base tests for each vector storage.
- */
-public abstract class VectorBaseStorageTest<T extends VectorStorage> extends ExternalizeTest<T> {
- /** */
- protected T storage;
-
- /** */
- @Before
- public abstract void setUp();
-
- /** */
- @After
- public void tearDown() throws Exception {
- storage.destroy();
- }
-
- /** */
- @Test
- public void getSet() throws Exception {
- for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++) {
- double random = Math.random();
-
- storage.set(i, random);
-
- assertEquals(MathTestConstants.WRONG_DATA_ELEMENT, storage.get(i), random, MathTestConstants.NIL_DELTA);
- }
- }
-
- /** */
- @Test
- public void size() {
- assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.size() == MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Override public void externalizeTest() {
- super.externalizeTest(storage);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java
deleted file mode 100644
index 2645926..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/storage/vector/VectorOffheapStorageTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * 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.storage.vector;
-
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Unit tests for {@link DenseLocalOffHeapVectorStorage}.
- */
-public class VectorOffheapStorageTest extends VectorBaseStorageTest<DenseLocalOffHeapVectorStorage> {
- /** */
- @Before
- public void setUp() {
- storage = new DenseLocalOffHeapVectorStorage(MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void isArrayBased() throws Exception {
- assertFalse(MathTestConstants.UNEXPECTED_VAL, storage.isArrayBased());
- }
-
- /** */
- @Test
- public void data() throws Exception {
- assertNull(MathTestConstants.NULL_VAL, storage.data());
- }
-
- /** */
- @Test
- public void isSequentialAccess() throws Exception {
- assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isSequentialAccess());
- }
-
- /** */
- @Test
- public void isDense() throws Exception {
- assertTrue(MathTestConstants.UNEXPECTED_VAL, storage.isDense());
- }
-
- /** */
- @Test
- public void equalsTest() {
- //noinspection EqualsWithItself
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, storage.equals(storage));
-
- //noinspection EqualsBetweenInconvertibleTypes
- assertFalse(MathTestConstants.VALUES_SHOULD_BE_NOT_EQUALS,
- storage.equals(new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE)));
- }
-
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java
deleted file mode 100644
index c7927a5..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/AbstractVectorTest.java
+++ /dev/null
@@ -1,543 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Arrays;
-import java.util.stream.StreamSupport;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.math.impls.storage.vector.ArrayVectorStorage;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Unit test for {@link AbstractVector}.
- */
-public class AbstractVectorTest {
- /** */
- private AbstractVector testVector;
-
- /** */
- @Before
- public void setUp() {
- testVector = getAbstractVector();
- }
-
- /** */
- @Test
- public void setStorage() {
- testVector.setStorage(createStorage());
-
- assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void size() {
- testVector.setStorage(createStorage());
- assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE);
-
- testVector.setStorage(new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE + MathTestConstants.STORAGE_SIZE));
- assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE + MathTestConstants.STORAGE_SIZE);
-
- testVector = getAbstractVector(createStorage());
- assertTrue(testVector.size() == MathTestConstants.STORAGE_SIZE);
- }
-
- /** */
- @Test
- public void getPositive() {
- testVector = getAbstractVector(createStorage());
-
- for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
- assertNotNull(MathTestConstants.NULL_VALUES, testVector.get(i));
-
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void getNegative0() {
- testVector.get(0);
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void getNegative1() {
- testVector.setStorage(createStorage());
-
- testVector.get(-1);
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void getNegative2() {
- testVector.setStorage(createStorage());
-
- testVector.get(testVector.size() + 1);
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void getXNegative0() {
- testVector.getX(0);
- }
-
- /** */
- @Test(expected = ArrayIndexOutOfBoundsException.class)
- public void getXNegative1() {
- testVector.setStorage(createStorage());
-
- testVector.getX(-1);
- }
-
- /** */
- @Test(expected = ArrayIndexOutOfBoundsException.class)
- public void getXNegative2() {
- testVector.setStorage(createStorage());
-
- testVector.getX(MathTestConstants.STORAGE_SIZE + 1);
- }
-
- /** */
- @Test
- public void set() {
- double[] data = initVector();
-
- for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
- testVector.set(i, Math.exp(data[i]));
-
- for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.get(i), Math.exp(data[i]), MathTestConstants.NIL_DELTA);
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void setNegative0() {
- testVector.set(-1, -1);
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void setNegative1() {
- initVector();
-
- testVector.set(-1, -1);
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void setNegative2() {
- initVector();
-
- testVector.set(MathTestConstants.STORAGE_SIZE + 1, -1);
- }
-
- /** */
- @Test(expected = IndexOutOfBoundsException.class)
- public void setXNegative0() {
- initVector();
-
- testVector.setX(-1, -1);
- }
-
- /** */
- @Test(expected = IndexOutOfBoundsException.class)
- public void setXNegative1() {
- initVector();
-
- testVector.setX(MathTestConstants.STORAGE_SIZE + 1, -1);
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void setXNegative2() {
- testVector.setX(-1, -1);
- }
-
- /** */
- @Test
- public void isZero() {
- assertTrue(MathTestConstants.UNEXPECTED_VAL, testVector.isZero(0d));
-
- assertFalse(MathTestConstants.UNEXPECTED_VAL, testVector.isZero(1d));
- }
-
- /** */
- @Test
- public void guid() {
- assertNotNull(MathTestConstants.NULL_GUID, testVector.guid());
-
- assertEquals(MathTestConstants.UNEXPECTED_GUID_VAL, testVector.guid(), testVector.guid());
-
- assertFalse(MathTestConstants.EMPTY_GUID, testVector.guid().toString().isEmpty());
-
- testVector = getAbstractVector(createStorage());
-
- assertNotNull(MathTestConstants.NULL_GUID, testVector.guid());
-
- assertEquals(MathTestConstants.UNEXPECTED_GUID_VAL, testVector.guid(), testVector.guid());
-
- assertFalse(MathTestConstants.EMPTY_GUID, testVector.guid().toString().isEmpty());
- }
-
- /** */
- @Test
- public void equalsTest() {
- VectorStorage storage = createStorage();
-
- AbstractVector testVector1 = getAbstractVector();
-
- testVector1.setStorage(storage);
-
- AbstractVector testVector2 = getAbstractVector();
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector, testVector);
-
- testVector2.setStorage(storage);
-
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, testVector1.equals(testVector2));
-
- assertFalse(MathTestConstants.VALUES_SHOULD_BE_NOT_EQUALS, testVector1.equals(testVector));
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void all() {
- assertNotNull(MathTestConstants.NULL_VAL, testVector.all());
-
- assertNotNull(MathTestConstants.NULL_VAL, getAbstractVector(createStorage()).all());
-
- getAbstractVector().all().iterator().next();
- }
-
- /** */
- @Test
- public void nonZeroElements() {
- VectorStorage storage = createStorage();
-
- double[] data = storage.data();
-
- testVector = getAbstractVector(storage);
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.nonZeroElements(), Arrays.stream(data).filter(x -> x != 0d).count());
-
- addNilValues(data);
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.nonZeroElements(), Arrays.stream(data).filter(x -> x != 0d).count());
- }
-
- /** */
- @Test
- public void foldMapWithSecondVector() {
- double[] data0 = initVector();
-
- VectorStorage storage1 = createStorage();
-
- double[] data1 = storage1.data().clone();
-
- AbstractVector testVector1 = getAbstractVector(storage1);
-
- String testVal = "";
-
- for (int i = 0; i < data0.length; i++)
- testVal += data0[i] + data1[i];
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.foldMap(testVector1, (string, xi) -> string.concat(xi.toString()), Functions.PLUS, ""), testVal);
- }
-
- /** */
- @Test
- public void nonZeroes() {
- assertNotNull(MathTestConstants.NULL_VAL, testVector.nonZeroes());
-
- double[] data = initVector();
-
- assertNotNull(MathTestConstants.NULL_VAL, testVector.nonZeroes());
-
- Assert.assertEquals(MathTestConstants.VAL_NOT_EQUALS, StreamSupport.stream(testVector.nonZeroes().spliterator(), false).count(), Arrays.stream(data).filter(x -> x != 0d).count());
-
- addNilValues(data);
-
- Assert.assertEquals(MathTestConstants.VAL_NOT_EQUALS, StreamSupport.stream(testVector.nonZeroes().spliterator(), false).count(), Arrays.stream(data).filter(x -> x != 0d).count());
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void nonZeroesEmpty() {
- testVector.nonZeroes().iterator().next();
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void assign() {
- testVector.assign(MathTestConstants.TEST_VAL);
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void assignArr() {
- testVector.assign(new double[1]);
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void assignArrEmpty() {
- testVector.assign(new double[0]);
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void dotNegative() {
- testVector.dot(getAbstractVector(createEmptyStorage()));
- }
-
- /** */
- @Test
- public void dotSelf() {
- double[] data = initVector();
-
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, testVector.dotSelf(), Arrays.stream(data).reduce(0, (x, y) -> x + y * y), MathTestConstants.NIL_DELTA);
- }
-
- /** */
- @Test
- public void getStorage() {
- assertNotNull(MathTestConstants.NULL_VAL, getAbstractVector(createEmptyStorage()));
- assertNotNull(MathTestConstants.NULL_VAL, getAbstractVector(createStorage()));
- testVector.setStorage(createStorage());
- assertNotNull(MathTestConstants.NULL_VAL, testVector.getStorage());
- }
-
- /** */
- @Test
- public void getElement() {
- double[] data = initVector();
-
- for (int i = 0; i < data.length; i++) {
- assertNotNull(MathTestConstants.NULL_VAL, testVector.getElement(i));
-
- assertEquals(MathTestConstants.UNEXPECTED_VAL, testVector.getElement(i).get(), data[i], MathTestConstants.NIL_DELTA);
-
- testVector.getElement(i).set(++data[i]);
-
- assertEquals(MathTestConstants.UNEXPECTED_VAL, testVector.getElement(i).get(), data[i], MathTestConstants.NIL_DELTA);
- }
- }
-
- /**
- * Create {@link AbstractVector} with storage for tests.
- *
- * @param storage {@link VectorStorage}
- * @return AbstractVector.
- */
- private AbstractVector getAbstractVector(VectorStorage storage) {
- return new AbstractVector(storage) { // TODO: find out how to fix warning about missing constructor
- /** */
- @Override public boolean isDense() {
- return false;
- }
-
- /** */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return null;
- }
-
- /** */
- @Override public Vector copy() {
- return getAbstractVector(this.getStorage());
- }
-
- /** */
- @Override public Vector like(int crd) {
- return null;
- }
-
- /** */
- @Override public Vector normalize() {
- return null;
- }
-
- /** */
- @Override public Vector normalize(double power) {
- return null;
- }
-
- /** */
- @Override public Vector logNormalize() {
- return null;
- }
-
- /** */
- @Override public Vector logNormalize(double power) {
- return null;
- }
-
- /** */
- @Override public Vector viewPart(int off, int len) {
- return null;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
- };
- }
-
- /**
- * Create empty {@link AbstractVector} for tests.
- *
- * @return AbstractVector.
- */
- private AbstractVector getAbstractVector() {
- return new AbstractVector() { // TODO: find out how to fix warning about missing constructor
- /** */
- @Override public boolean isDense() {
- return false;
- }
-
- /** */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return null;
- }
-
- /** */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** */
- @Override public Vector copy() {
- return getAbstractVector(this.getStorage());
- }
-
- /** */
- @Override public Vector like(int crd) {
- return null;
- }
-
- /** */
- @Override public Vector normalize() {
- return null;
- }
-
- /** */
- @Override public Vector normalize(double power) {
- return null;
- }
-
- /** */
- @Override public Vector logNormalize() {
- return null;
- }
-
- /** */
- @Override public Vector logNormalize(double power) {
- return null;
- }
-
- /** */
- @Override public Vector viewPart(int off, int len) {
- return null;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
- };
- }
-
- /**
- * Create {@link VectorStorage} for tests.
- *
- * @return VectorStorage
- */
- private VectorStorage createEmptyStorage() {
- return new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE);
- }
-
- /**
- * Create filled {@link VectorStorage} for tests.
- *
- * @return VectorStorage.
- */
- private VectorStorage createStorage() {
- ArrayVectorStorage storage = new ArrayVectorStorage(MathTestConstants.STORAGE_SIZE);
-
- for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++)
- storage.set(i, Math.random());
-
- return storage;
- }
-
- /**
- * Init vector and return initialized values.
- *
- * @return Initial values.
- */
- private double[] initVector() {
- VectorStorage storage = createStorage();
- double[] data = storage.data().clone();
-
- testVector = getAbstractVector(storage);
- return data;
- }
-
- /**
- * Add some zeroes to vector elements.
- */
- private void addNilValues() {
- testVector.set(10, 0);
- testVector.set(50, 0);
- }
-
- /**
- * Add some zeroes to vector elements. Also set zeroes to the same elements in reference array data
- */
- private void addNilValues(double[] testRef) {
- addNilValues();
- testRef[10] = 0;
- testRef[50] = 0;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java
deleted file mode 100644
index f276820..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/CacheVectorTest.java
+++ /dev/null
@@ -1,417 +0,0 @@
-package org.apache.ignite.math.impls.vector;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.util.stream.IntStream;
-import junit.framework.TestCase;
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.internal.util.IgniteUtils;
-import org.apache.ignite.math.IdentityValueMapper;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorKeyMapper;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
-import org.apache.ignite.testframework.junits.common.GridCommonTest;
-
-/**
- * Tests for {@link CacheVector}.
- */
-@GridCommonTest(group = "Distributed Models")
-public class CacheVectorTest extends GridCommonAbstractTest {
- /** Number of nodes in grid */
- private static final int NODE_COUNT = 3;
- /** Cache name. */
- private static final String CACHE_NAME = "test-cache";
- /** Cache size. */
- private static final int size = MathTestConstants.STORAGE_SIZE;
- /** Grid instance. */
- private Ignite ignite;
- /** Default key mapper. */
- private VectorKeyMapper<Integer> keyMapper = new TestKeyMapper();
-
- /**
- * Default constructor.
- */
- public CacheVectorTest() {
- super(false);
- }
-
- /** {@inheritDoc} */
- @Override protected void beforeTestsStarted() throws Exception {
- for (int i = 1; i <= NODE_COUNT; i++)
- startGrid(i);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTestsStopped() throws Exception {
- stopAllGrids();
- }
-
- /** {@inheritDoc} */
- @Override protected void beforeTest() throws Exception {
- ignite = grid(NODE_COUNT);
-
- ignite.configuration().setPeerClassLoadingEnabled(true);
- }
-
- /** {@inheritDoc} */
- @Override protected void afterTest() throws Exception {
- ignite.destroyCache(CACHE_NAME);
- }
-
- /** */
- public void testGetSet() throws Exception {
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- for (int i = 0; i < size; i++) {
- double random = Math.random();
- cacheVector.set(i, random);
- assertEquals("Unexpected value.", random, cacheVector.get(i), 0d);
- }
- }
-
- /** */
- public void testMap() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
-
- cacheVector.map(value -> 110d);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), 110d, 0d);
- }
-
- /** */
- public void testMapBiFunc() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
-
- cacheVector.map(Functions.PLUS, 1d);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), 1d, 0d);
- }
-
- /** */
- public void testSum() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
-
- assertEquals("Unexpected value.", cacheVector.sum(), 0d, 0d);
-
- cacheVector.assign(1d);
-
- assertEquals("Unexpected value.", cacheVector.sum(), size, 0d);
- }
-
- /** */
- public void testSumNegative() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- try {
- double d = cacheVector.sum();
- fail();
- }
- catch (NullPointerException e) {
- // No-op.
- }
- }
-
- /** */
- public void testAssign() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
-
- cacheVector.assign(1d);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), 1d, 0d);
- }
-
- /** */
- public void testAssignRange() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- cacheVector.assign(IntStream.range(0, size).asDoubleStream().toArray());
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), i, 0d);
- }
-
- /** */
- public void testAssignVector() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
-
- cacheVector.assign(testVec);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), testVec.get(i), 0d);
- }
-
- /** */
- public void testAssignFunc() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- cacheVector.assign(idx -> idx);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), i, 0d);
- }
-
- /** */
- public void testPlus() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
-
- cacheVector.plus(1d);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), 1d, 0d);
- }
-
- /** */
- public void testPlusVec() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
-
- try {
- cacheVector.plus(testVec);
- TestCase.fail();
- }
- catch (UnsupportedOperationException ignored) {
-
- }
- }
-
- /** */
- public void testDivide() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- final int size = MathTestConstants.STORAGE_SIZE;
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
- cacheVector.assign(1d);
-
- cacheVector.divide(2d);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), 1d / 2d, 0d);
- }
-
- /** */
- public void testTimes() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- final int size = MathTestConstants.STORAGE_SIZE;
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- initVector(cacheVector);
- cacheVector.assign(1d);
-
- cacheVector.times(2d);
-
- for (int i = 0; i < size; i++)
- assertEquals("Unexpected value.", cacheVector.get(i), 2d, 0d);
- }
-
- /** */
- public void testTimesVector() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- cacheVector.assign(1d);
- Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
-
- try {
- cacheVector.times(testVec);
- TestCase.fail();
- }
- catch (UnsupportedOperationException ignored) {
-
- }
-
- }
-
- /** */
- public void testMin() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
-
- cacheVector.assign(testVec);
-
- assertEquals("Unexpected value.", cacheVector.minValue(), 0d, 0d);
- }
-
- /** */
- public void testMax() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- Vector testVec = new DenseLocalOnHeapVector(IntStream.range(0, size).asDoubleStream().toArray());
-
- cacheVector.assign(testVec);
-
- assertEquals("Unexpected value.", cacheVector.maxValue(), testVec.get(size - 1), 0d);
- }
-
- /** */
- public void testLike() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- try {
- cacheVector.like(size);
- TestCase.fail("Unsupported case");
- }
- catch (UnsupportedOperationException ignored) {
-
- }
- }
-
- /** */
- public void testLikeMatrix() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- try {
- cacheVector.likeMatrix(size, size);
- TestCase.fail("Unsupported case");
- }
- catch (UnsupportedOperationException ignored) {
-
- }
- }
-
- /** */
- public void testCopy() {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- try {
- cacheVector.copy();
- TestCase.fail("Unsupported case");
- }
- catch (UnsupportedOperationException ignored) {
-
- }
- }
-
- /** */
- public void testExternalize() throws IOException, ClassNotFoundException {
- IgniteUtils.setCurrentIgniteName(ignite.configuration().getIgniteInstanceName());
-
- IdentityValueMapper valMapper = new IdentityValueMapper();
- CacheVector<Integer, Double> cacheVector = new CacheVector<>(size, getCache(), keyMapper, valMapper);
-
- cacheVector.set(1, 1.0);
-
- ByteArrayOutputStream byteArrOutputStream = new ByteArrayOutputStream();
- ObjectOutputStream objOutputStream = new ObjectOutputStream(byteArrOutputStream);
-
- objOutputStream.writeObject(cacheVector);
-
- ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(byteArrOutputStream.toByteArray());
- ObjectInputStream objInputStream = new ObjectInputStream(byteArrInputStream);
-
- CacheVector objRestored = (CacheVector)objInputStream.readObject();
-
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, cacheVector.equals(objRestored));
- assertEquals(MathTestConstants.VAL_NOT_EQUALS, objRestored.get(1), 1.0, 0.0);
- }
-
- /** */
- private void initVector(CacheVector cacheVector) {
- for (int i = 0; i < cacheVector.size(); i++)
- cacheVector.set(i, 0d);
- }
-
- /** */
- private IgniteCache<Integer, Double> getCache() {
- assert ignite != null;
-
- CacheConfiguration cfg = new CacheConfiguration();
- cfg.setName(CACHE_NAME);
-
- IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(CACHE_NAME);
-
- assert cache != null;
- return cache;
- }
-
- /** */ private static class TestKeyMapper implements VectorKeyMapper<Integer> {
- /** {@inheritDoc} */
- @Override public Integer apply(int i) {
- return i;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isValid(Integer i) {
- return i < size;
- }
- }
-}
[21/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/functions/Functions.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/Functions.java b/modules/math/src/main/java/org/apache/ignite/math/functions/Functions.java
deleted file mode 100644
index 7100908..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/Functions.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * 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 < b ? -1 : a > 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/math/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java
deleted file mode 100644
index 22e8274..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteBiConsumer.java
+++ /dev/null
@@ -1,12 +0,0 @@
-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/math/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java
deleted file mode 100644
index 9d9c147..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteBiFunction.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java
deleted file mode 100644
index 1f7ca07..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteConsumer.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java
deleted file mode 100644
index 7a23d50..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteDoubleFunction.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java
deleted file mode 100644
index cfe89a4..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IgniteFunction.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java
deleted file mode 100644
index e5d69c7..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IntDoubleToVoidFunction.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java
deleted file mode 100644
index cad8c3c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IntIntDoubleToVoidFunction.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java b/modules/math/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java
deleted file mode 100644
index b31d9f9..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/IntIntToDoubleFunction.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/functions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/functions/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/functions/package-info.java
deleted file mode 100644
index 133e62c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/functions/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/impls/CacheUtils.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/CacheUtils.java b/modules/math/src/main/java/org/apache/ignite/math/impls/CacheUtils.java
deleted file mode 100644
index df33895..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/CacheUtils.java
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * 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);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java
deleted file mode 100644
index ca11e81..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java
+++ /dev/null
@@ -1,880 +0,0 @@
-/*
- * 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.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Random;
-import org.apache.ignite.lang.IgniteUuid;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.decompositions.LUDecomposition;
-import org.apache.ignite.math.exceptions.CardinalityException;
-import org.apache.ignite.math.exceptions.ColumnIndexException;
-import org.apache.ignite.math.exceptions.RowIndexException;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.functions.IntIntToDoubleFunction;
-import org.apache.ignite.math.impls.vector.MatrixVectorView;
-
-/**
- * This class provides a helper implementation of the {@link Matrix}
- * interface to minimize the effort required to implement it.
- * Subclasses may override some of the implemented methods if a more
- * specific or optimized implementation is desirable.
- *
- * TODO: add row/column optimization.
- */
-public abstract class AbstractMatrix implements Matrix {
- // Stochastic sparsity analysis.
- /** */
- private static final double Z95 = 1.959964;
- /** */
- private static final double Z80 = 1.281552;
- /** */
- private static final int MAX_SAMPLES = 500;
- /** */
- private static final int MIN_SAMPLES = 15;
-
- /** Cached minimum element. */
- private Element minElm;
- /** Cached maximum element. */
- private Element maxElm = null;
-
- /** Matrix storage implementation. */
- private MatrixStorage sto;
-
- /** Meta attributes storage. */
- private Map<String, Object> meta = new HashMap<>();
-
- /** Matrix's GUID. */
- private IgniteUuid guid = IgniteUuid.randomUuid();
-
- /**
- * @param sto Backing {@link MatrixStorage}.
- */
- public AbstractMatrix(MatrixStorage sto) {
- this.sto = sto;
- }
-
- /**
- *
- */
- public AbstractMatrix() {
- // No-op.
- }
-
- /**
- * @param sto Backing {@link MatrixStorage}.
- */
- protected void setStorage(MatrixStorage sto) {
- assert sto != null;
-
- this.sto = sto;
- }
-
- /**
- * @param row Row index in the matrix.
- * @param col Column index in the matrix.
- * @param v Value to set.
- */
- protected void storageSet(int row, int col, double v) {
- sto.set(row, col, v);
-
- // Reset cached values.
- minElm = maxElm = null;
- }
-
- /**
- * @param row Row index in the matrix.
- * @param col Column index in the matrix.
- */
- protected double storageGet(int row, int col) {
- return sto.get(row, col);
- }
-
- /** {@inheritDoc} */
- @Override public Element maxElement() {
- if (maxElm == null) {
- double max = Double.NEGATIVE_INFINITY;
- int row = 0, col = 0;
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++) {
- double d = storageGet(x, y);
-
- if (d > max) {
- max = d;
- row = x;
- col = y;
- }
- }
-
- maxElm = mkElement(row, col);
- }
-
- return maxElm;
- }
-
- /** {@inheritDoc} */
- @Override public Element minElement() {
- if (minElm == null) {
- double min = Double.MAX_VALUE;
- int row = 0, col = 0;
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++) {
- double d = storageGet(x, y);
-
- if (d < min) {
- min = d;
- row = x;
- col = y;
- }
- }
-
- minElm = mkElement(row, col);
- }
-
- return minElm;
- }
-
- /** {@inheritDoc} */
- @Override public double maxValue() {
- return maxElement().get();
- }
-
- /** {@inheritDoc} */
- @Override public double minValue() {
- return minElement().get();
- }
-
- /**
- * @param row Row index in the matrix.
- * @param col Column index in the matrix.
- */
- private Element mkElement(int row, int col) {
- return new Element() {
- /** {@inheritDoc} */
- @Override public double get() {
- return storageGet(row, col);
- }
-
- /** {@inheritDoc} */
- @Override public int row() {
- return row;
- }
-
- /** {@inheritDoc} */
- @Override public int column() {
- return col;
- }
-
- /** {@inheritDoc} */
- @Override public void set(double d) {
- storageSet(row, col, d);
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public Element getElement(int row, int col) {
- return mkElement(row, col);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix swapRows(int row1, int row2) {
- checkRowIndex(row1);
- checkRowIndex(row2);
-
- int cols = columnSize();
-
- for (int y = 0; y < cols; y++) {
- double v = getX(row1, y);
-
- setX(row1, y, getX(row2, y));
- setX(row2, y, v);
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix swapColumns(int col1, int col2) {
- checkColumnIndex(col1);
- checkColumnIndex(col2);
-
- int rows = rowSize();
-
- for (int x = 0; x < rows; x++) {
- double v = getX(x, col1);
-
- setX(x, col1, getX(x, col2));
- setX(x, col2, v);
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public MatrixStorage getStorage() {
- return sto;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return sto.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return sto.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return sto.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return sto.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return sto.isArrayBased();
- }
-
- /**
- * Check row index bounds.
- *
- * @param row Row index.
- */
- private void checkRowIndex(int row) {
- if (row < 0 || row >= rowSize())
- throw new RowIndexException(row);
- }
-
- /**
- * Check column index bounds.
- *
- * @param col Column index.
- */
- private void checkColumnIndex(int col) {
- if (col < 0 || col >= columnSize())
- throw new ColumnIndexException(col);
- }
-
- /**
- * Check column and row index bounds.
- *
- * @param row Row index.
- * @param col Column index.
- */
- protected void checkIndex(int row, int col) {
- checkRowIndex(row);
- checkColumnIndex(col);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(sto);
- out.writeObject(meta);
- out.writeObject(guid);
- }
-
- /** {@inheritDoc} */
- @Override public Map<String, Object> getMetaStorage() {
- return meta;
- }
-
- /** {@inheritDoc} */
- @SuppressWarnings("unchecked")
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- sto = (MatrixStorage)in.readObject();
- meta = (Map<String, Object>)in.readObject();
- guid = (IgniteUuid)in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assign(double val) {
- if (sto.isArrayBased())
- for (double[] column : sto.data())
- Arrays.fill(column, val);
- else {
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- storageSet(x, y, val);
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assign(IntIntToDoubleFunction fun) {
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- storageSet(x, y, fun.apply(x, y));
-
- return this;
- }
-
- /** */
- private void checkCardinality(Matrix mtx) {
- checkCardinality(mtx.rowSize(), mtx.columnSize());
- }
-
- /** */
- private void checkCardinality(int rows, int cols) {
- if (rows != rowSize())
- throw new CardinalityException(rowSize(), rows);
-
- if (cols != columnSize())
- throw new CardinalityException(columnSize(), cols);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assign(double[][] vals) {
- checkCardinality(vals.length, vals[0].length);
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- storageSet(x, y, vals[x][y]);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assign(Matrix mtx) {
- checkCardinality(mtx);
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- storageSet(x, y, mtx.getX(x, y));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix map(IgniteDoubleFunction<Double> fun) {
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- storageSet(x, y, fun.apply(storageGet(x, y)));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix map(Matrix mtx, IgniteBiFunction<Double, Double, Double> fun) {
- checkCardinality(mtx);
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- storageSet(x, y, fun.apply(storageGet(x, y), mtx.getX(x, y)));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assignColumn(int col, org.apache.ignite.math.Vector vec) {
- checkColumnIndex(col);
-
- int rows = rowSize();
-
- for (int x = 0; x < rows; x++)
- storageSet(x, col, vec.getX(x));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assignRow(int row, Vector vec) {
- checkRowIndex(row);
-
- int cols = columnSize();
-
- if (cols != vec.size())
- throw new CardinalityException(cols, vec.size());
-
- if (sto.isArrayBased() && vec.getStorage().isArrayBased())
- System.arraycopy(vec.getStorage().data(), 0, sto.data()[row], 0, cols);
- else
- for (int y = 0; y < cols; y++)
- storageSet(row, y, vec.getX(y));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector foldRows(IgniteFunction<Vector, Double> fun) {
- int rows = rowSize();
-
- Vector vec = likeVector(rows);
-
- for (int i = 0; i < rows; i++)
- vec.setX(i, fun.apply(viewRow(i)));
-
- return vec;
- }
-
- /** {@inheritDoc} */
- @Override public Vector foldColumns(IgniteFunction<Vector, Double> fun) {
- int cols = columnSize();
-
- Vector vec = likeVector(cols);
-
- for (int i = 0; i < cols; i++)
- vec.setX(i, fun.apply(viewColumn(i)));
-
- return vec;
- }
-
- /** {@inheritDoc} */
- @Override public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun,
- T zeroVal) {
- T res = zeroVal;
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- res = foldFun.apply(res, mapFun.apply(storageGet(x, y)));
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return sto.columnSize();
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return sto.rowSize();
- }
-
- /** {@inheritDoc} */
- @Override public double determinant() {
- //TODO: This decomposition should be cached
- LUDecomposition dec = new LUDecomposition(this);
- double res = dec.determinant();
- dec.destroy();
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix inverse() {
- if (rowSize() != columnSize())
- throw new CardinalityException(rowSize(), columnSize());
-
- //TODO: This decomposition should be cached
- LUDecomposition dec = new LUDecomposition(this);
-
- Matrix res = dec.solve(likeIdentity());
- dec.destroy();
-
- return res;
- }
-
- /** */
- protected Matrix likeIdentity() {
- int n = rowSize();
- Matrix res = like(n, n);
-
- for (int i = 0; i < n; i++)
- res.setX(i, i, 1.0);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix divide(double d) {
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- setX(x, y, getX(x, y) / d);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int row, int col) {
- checkIndex(row, col);
-
- return storageGet(row, col);
- }
-
- /** {@inheritDoc} */
- @Override public double getX(int row, int col) {
- return storageGet(row, col);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix minus(Matrix mtx) {
- int rows = rowSize();
- int cols = columnSize();
-
- checkCardinality(rows, cols);
-
- Matrix res = like(rows, cols);
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- res.setX(x, y, getX(x, y) - mtx.getX(x, y));
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix plus(double x) {
- Matrix cp = copy();
-
- cp.map(Functions.plus(x));
-
- return cp;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix plus(Matrix mtx) {
- int rows = rowSize();
- int cols = columnSize();
-
- checkCardinality(rows, cols);
-
- Matrix res = like(rows, cols);
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- res.setX(x, y, getX(x, y) + mtx.getX(x, y));
-
- return res;
-
- }
-
- /** {@inheritDoc} */
- @Override public IgniteUuid guid() {
- return guid;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix set(int row, int col, double val) {
- checkIndex(row, col);
-
- storageSet(row, col, val);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix setRow(int row, double[] data) {
- checkRowIndex(row);
-
- int cols = columnSize();
-
- if (cols != data.length)
- throw new CardinalityException(cols, data.length);
-
- if (sto.isArrayBased())
- System.arraycopy(data, 0, sto.data()[row], 0, cols);
- else
- for (int y = 0; y < cols; y++)
- setX(row, y, data[y]);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix setColumn(int col, double[] data) {
- checkColumnIndex(col);
-
- int rows = rowSize();
-
- if (rows != data.length)
- throw new CardinalityException(rows, data.length);
-
- for (int x = 0; x < rows; x++)
- setX(x, col, data[x]);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix setX(int row, int col, double val) {
- storageSet(row, col, val);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix times(double x) {
- Matrix cp = copy();
-
- cp.map(Functions.mult(x));
-
- return cp;
- }
-
- /** {@inheritDoc} */
- @Override public double maxAbsRowSumNorm() {
- double max = 0.0;
-
- int rows = rowSize();
- int cols = columnSize();
-
- for (int x = 0; x < rows; x++) {
- double sum = 0;
-
- for (int y = 0; y < cols; y++)
- sum += Math.abs(getX(x, y));
-
- if (sum > max)
- max = sum;
- }
-
- return max;
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(Vector vec) {
- int cols = columnSize();
-
- if (cols != vec.size())
- throw new CardinalityException(cols, vec.size());
-
- int rows = rowSize();
-
- Vector res = likeVector(rows);
-
- for (int x = 0; x < rows; x++)
- res.setX(x, vec.dot(viewRow(x)));
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix times(Matrix mtx) {
- int cols = columnSize();
-
- if (cols != mtx.rowSize())
- throw new CardinalityException(cols, mtx.rowSize());
-
- int rows = rowSize();
-
- int mtxCols = mtx.columnSize();
-
- Matrix res = like(rows, mtxCols);
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < mtxCols; y++) {
- double sum = 0.0;
-
- for (int k = 0; k < cols; k++)
- sum += getX(x, k) * mtx.getX(k, y);
-
- res.setX(x, y, sum);
- }
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- int rows = rowSize();
- int cols = columnSize();
-
- double sum = 0.0;
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- sum += getX(x, y);
-
- return sum;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix transpose() {
- int rows = rowSize();
- int cols = columnSize();
-
- Matrix mtx = like(cols, rows);
-
- for (int x = 0; x < rows; x++)
- for (int y = 0; y < cols; y++)
- mtx.setX(y, x, getX(x, y));
-
- return mtx;
- }
-
- /** {@inheritDoc} */
- @Override public boolean density(double threshold) {
- assert threshold >= 0.0 && threshold <= 1.0;
-
- int n = MIN_SAMPLES;
- int rows = rowSize();
- int cols = columnSize();
-
- double mean = 0.0;
- double pq = threshold * (1 - threshold);
-
- Random rnd = new Random();
-
- for (int i = 0; i < MIN_SAMPLES; i++)
- if (getX(rnd.nextInt(rows), rnd.nextInt(cols)) != 0.0)
- mean++;
-
- mean /= MIN_SAMPLES;
-
- double iv = Z80 * Math.sqrt(pq / n);
-
- if (mean < threshold - iv)
- return false; // Sparse.
- else if (mean > threshold + iv)
- return true; // Dense.
-
- while (n < MAX_SAMPLES) {
- // Determine upper bound we may need for 'n' to likely relinquish the uncertainty.
- // Here, we use confidence interval formula but solved for 'n'.
- double ivX = Math.max(Math.abs(threshold - mean), 1e-11);
-
- double stdErr = ivX / Z80;
- double nX = Math.min(Math.max((int)Math.ceil(pq / (stdErr * stdErr)), n), MAX_SAMPLES) - n;
-
- if (nX < 1.0) // IMPL NOTE this can happen with threshold 1.0
- nX = 1.0;
-
- double meanNext = 0.0;
-
- for (int i = 0; i < nX; i++)
- if (getX(rnd.nextInt(rows), rnd.nextInt(cols)) != 0.0)
- meanNext++;
-
- mean = (n * mean + meanNext) / (n + nX);
-
- n += nX;
-
- // Are we good now?
- iv = Z80 * Math.sqrt(pq / n);
-
- if (mean < threshold - iv)
- return false; // Sparse.
- else if (mean > threshold + iv)
- return true; // Dense.
- }
-
- return mean > threshold; // Dense if mean > threshold.
- }
-
- /** {@inheritDoc} */
- @Override public Matrix viewPart(int[] off, int[] size) {
- return new MatrixView(this, off[0], off[1], size[0], size[1]);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix viewPart(int rowOff, int rows, int colOff, int cols) {
- return viewPart(new int[] {rowOff, colOff}, new int[] {rows, cols});
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewRow(int row) {
- return new MatrixVectorView(this, row, 0, 0, 1);
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewColumn(int col) {
- return new MatrixVectorView(this, 0, col, 1, 0);
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewDiagonal() {
- return new MatrixVectorView(this, 0, 0, 1, 1);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- Matrix cp = like(rowSize(), columnSize());
-
- cp.assign(this);
-
- return cp;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + guid.hashCode();
- res = res * 37 + sto.hashCode();
- res = res * 37 + meta.hashCode();
-
- return res;
- }
-
- /**
- * {@inheritDoc}
- *
- * We ignore guid's for comparisons.
- */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- AbstractMatrix that = (AbstractMatrix)o;
-
- MatrixStorage sto = getStorage();
-
- return (sto != null ? sto.equals(that.getStorage()) : that.getStorage() == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java
deleted file mode 100644
index 8ce1192..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixKeyMapper;
-import org.apache.ignite.math.ValueMapper;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.impls.CacheUtils;
-import org.apache.ignite.math.impls.storage.matrix.CacheMatrixStorage;
-
-/**
- * Matrix based on existing cache and key and value mapping functions.
- */
-public class CacheMatrix<K, V> extends AbstractMatrix {
- /**
- *
- */
- public CacheMatrix() {
- // No-op.
- }
-
- /**
- * Creates new matrix over existing cache.
- *
- * @param rows
- * @param cols
- * @param cache
- * @param keyMapper
- * @param valMapper
- */
- public CacheMatrix(
- int rows,
- int cols,
- IgniteCache<K, V> cache,
- MatrixKeyMapper<K> keyMapper,
- ValueMapper<V> valMapper) {
- assert rows > 0;
- assert cols > 0;
- assert cache != null;
- assert keyMapper != null;
- assert valMapper != null;
-
- setStorage(new CacheMatrixStorage<>(rows, cols, cache, keyMapper, valMapper));
- }
-
- /**
- *
- *
- */
- @SuppressWarnings({"unchecked"})
- private CacheMatrixStorage<K, V> storage() {
- return (CacheMatrixStorage<K, V>)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- throw new UnsupportedOperationException();
- }
-
- /**
- * Return the same matrix with updates values (broken contract).
- *
- * @param d
- */
- @Override public Matrix divide(double d) {
- return mapOverValues((Double v) -> v / d);
- }
-
- /**
- * Return the same matrix with updates values (broken contract).
- *
- * @param x
- */
- @Override public Matrix plus(double x) {
- return mapOverValues((Double v) -> v + x);
- }
-
- /**
- * Return the same matrix with updates values (broken contract).
- *
- * @param x
- */
- @Override public Matrix times(double x) {
- return mapOverValues((Double v) -> v * x);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assign(double val) {
- return mapOverValues((Double v) -> val);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix map(IgniteDoubleFunction<Double> fun) {
- return mapOverValues(fun::apply);
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- CacheMatrixStorage<K, V> sto = storage();
-
- return CacheUtils.sum(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
- }
-
- /** {@inheritDoc} */
- @Override public double maxValue() {
- CacheMatrixStorage<K, V> sto = storage();
-
- return CacheUtils.max(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
- }
-
- /** {@inheritDoc} */
- @Override public double minValue() {
- CacheMatrixStorage<K, V> sto = storage();
-
- return CacheUtils.min(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
- }
-
- /**
- * @param mapper
- */
- private Matrix mapOverValues(IgniteFunction<Double, Double> mapper) {
- CacheMatrixStorage<K, V> sto = storage();
-
- CacheUtils.map(sto.cache().getName(), sto.keyMapper(), sto.valueMapper(), mapper);
-
- return this;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java
deleted file mode 100644
index d5f8eca..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.storage.matrix.DenseOffHeapMatrixStorage;
-import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
-
-/**
- * Dense local off-heap implementation of the {@link Matrix} interface.
- */
-public class DenseLocalOffHeapMatrix extends AbstractMatrix {
- /** */
- public DenseLocalOffHeapMatrix() {
- // No-op.
- }
-
- /**
- * @param data Backing data array.
- */
- public DenseLocalOffHeapMatrix(double[][] data) {
- assert data != null;
-
- setStorage(new DenseOffHeapMatrixStorage(data));
- }
-
- /**
- * @param rows Amount of rows in matrix.
- * @param cols Amount of columns in matrix.
- */
- public DenseLocalOffHeapMatrix(int rows, int cols) {
- assert rows > 0;
- assert cols > 0;
-
- setStorage(new DenseOffHeapMatrixStorage(rows, cols));
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- DenseLocalOffHeapMatrix cp = new DenseLocalOffHeapMatrix(getStorage().rowSize(), getStorage().columnSize());
-
- cp.assign(this);
-
- return cp;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- return new DenseLocalOffHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- return new DenseLocalOffHeapVector(crd);
- }
-
- /** {@inheritDoc} */
- @Override public void destroy() {
- getStorage().destroy();
- }
-
- /** {@inheritDoc} */
- @Override protected Matrix likeIdentity() {
- int n = rowSize();
- Matrix res = like(n, n);
-
- // IMPL NOTE as opposed to on-heap matrices this one isn't initialized with zeroes
- for (int i = 0; i < n; i++)
- for (int j = 0; j < n; j++)
- res.setX(i, j, i == j ? 1.0 : 0.0);
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java
deleted file mode 100644
index 3cc3e4f..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.storage.matrix.ArrayMatrixStorage;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-
-/**
- * Basic implementation for matrix.
- *
- * This is a trivial implementation for matrix assuming dense logic, local on-heap JVM storage
- * based on <code>double[][]</code> array. It is only suitable for data sets where
- * local, non-distributed execution is satisfactory and on-heap JVM storage is enough
- * to keep the entire data set.
- */
-public class DenseLocalOnHeapMatrix extends AbstractMatrix {
- /**
- *
- */
- public DenseLocalOnHeapMatrix() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in matrix.
- * @param cols Amount of columns in matrix.
- */
- public DenseLocalOnHeapMatrix(int rows, int cols) {
- assert rows > 0;
- assert cols > 0;
-
- setStorage(new ArrayMatrixStorage(rows, cols));
- }
-
- /**
- * @param mtx Backing data array.
- */
- public DenseLocalOnHeapMatrix(double[][] mtx) {
- assert mtx != null;
-
- setStorage(new ArrayMatrixStorage(mtx));
- }
-
- /**
- * @param orig Original matrix.
- */
- private DenseLocalOnHeapMatrix(DenseLocalOnHeapMatrix orig) {
- assert orig != null;
-
- setStorage(new ArrayMatrixStorage(orig.rowSize(), orig.columnSize()));
-
- assign(orig);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- return new DenseLocalOnHeapMatrix(this);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- return new DenseLocalOnHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- return new DenseLocalOnHeapVector(crd);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java
deleted file mode 100644
index 0b1f97e..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.storage.matrix.DiagonalMatrixStorage;
-import org.apache.ignite.math.impls.vector.ConstantVector;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.apache.ignite.math.impls.vector.SingleElementVectorView;
-
-/**
- * Implementation of diagonal view of the {@link Matrix}.
- *
- * <p>See also: <a href="https://en.wikipedia.org/wiki/Diagonal_matrix">Wikipedia article</a>.</p>
- */
-public class DiagonalMatrix extends AbstractMatrix {
- /**
- *
- */
- public DiagonalMatrix() {
- // No-op.
- }
-
- /**
- * @param diagonal Backing {@link Vector}.
- */
- public DiagonalMatrix(Vector diagonal) {
- super(new DiagonalMatrixStorage(diagonal));
- }
-
- /**
- * @param mtx Backing {@link Matrix}.
- */
- public DiagonalMatrix(Matrix mtx) {
- super(new DiagonalMatrixStorage(mtx == null ? null : mtx.viewDiagonal()));
- }
-
- /**
- * @param vals Backing array of values at diagonal.
- */
- public DiagonalMatrix(double[] vals) {
- super(new DiagonalMatrixStorage(new DenseLocalOnHeapVector(vals)));
- }
-
- /**
- *
- *
- */
- private DiagonalMatrixStorage storage() {
- return (DiagonalMatrixStorage)getStorage();
- }
-
- /**
- * @param size Size of diagonal.
- * @param val Constant value at diagonal.
- */
- public DiagonalMatrix(int size, double val) {
- super(new DiagonalMatrixStorage(new ConstantVector(size, val)));
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewRow(int row) {
- return new SingleElementVectorView(storage().diagonal(), row);
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewColumn(int col) {
- return new SingleElementVectorView(storage().diagonal(), col);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- return new DiagonalMatrix(storage().diagonal());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- return storage().diagonal().likeMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- return storage().diagonal().like(crd);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java
deleted file mode 100644
index b180b5b..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IntIntDoubleToVoidFunction;
-import org.apache.ignite.math.functions.IntIntToDoubleFunction;
-import org.apache.ignite.math.impls.storage.matrix.FunctionMatrixStorage;
-
-/**
- * Implementation of {@link Matrix} that maps row and column index to {@link java.util.function} interfaces.
- */
-public class FunctionMatrix extends AbstractMatrix {
- /**
- *
- */
- public FunctionMatrix() {
- // No-op.
- }
-
- /**
- * Creates read-write or read-only function matrix.
- *
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param getFunc Function that returns value corresponding to given row and column index.
- * @param setFunc Set function. If {@code null} - this will be a read-only matrix.
- */
- public FunctionMatrix(int rows, int cols, IntIntToDoubleFunction getFunc, IntIntDoubleToVoidFunction setFunc) {
- assert rows > 0;
- assert cols > 0;
- assert getFunc != null;
-
- setStorage(new FunctionMatrixStorage(rows, cols, getFunc, setFunc));
- }
-
- /**
- * Creates read-only function matrix.
- *
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param getFunc Function that returns value corresponding to given row and column index.
- */
- public FunctionMatrix(int rows, int cols, IntIntToDoubleFunction getFunc) {
- assert rows > 0;
- assert cols > 0;
- assert getFunc != null;
-
- setStorage(new FunctionMatrixStorage(rows, cols, getFunc));
- }
-
- /**
- *
- *
- */
- private FunctionMatrixStorage storage() {
- return (FunctionMatrixStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- FunctionMatrixStorage sto = storage();
-
- return new FunctionMatrix(sto.rowSize(), sto.columnSize(), sto.getFunction(), sto.setFunction());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- FunctionMatrixStorage sto = storage();
-
- return new FunctionMatrix(rows, cols, sto.getFunction(), sto.setFunction());
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java
deleted file mode 100644
index 7b04dde..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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.matrix;
-
-import java.io.Externalizable;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.storage.matrix.MatrixDelegateStorage;
-
-/**
- * Implements the rectangular view into the parent {@link Matrix}.
- */
-public class MatrixView extends AbstractMatrix {
- /**
- * Constructor for {@link Externalizable} interface.
- */
- public MatrixView() {
- // No-op.
- }
-
- /**
- * @param parent Backing parent {@link Matrix}.
- * @param rowOff Row offset to parent matrix.
- * @param colOff Column offset to parent matrix.
- * @param rows Amount of rows in the view.
- * @param cols Amount of columns in the view.
- */
- public MatrixView(Matrix parent, int rowOff, int colOff, int rows, int cols) {
- this(parent == null ? null : parent.getStorage(), rowOff, colOff, rows, cols);
- }
-
- /**
- * @param sto Backing parent {@link MatrixStorage}.
- * @param rowOff Row offset to parent storage.
- * @param colOff Column offset to parent storage.
- * @param rows Amount of rows in the view.
- * @param cols Amount of columns in the view.
- */
- public MatrixView(MatrixStorage sto, int rowOff, int colOff, int rows, int cols) {
- super(new MatrixDelegateStorage(sto, rowOff, colOff, rows, cols));
- }
-
- /**
- *
- *
- */
- private MatrixDelegateStorage storage() {
- return (MatrixDelegateStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- MatrixDelegateStorage sto = storage();
-
- return new MatrixView(sto.delegate(), sto.rowOffset(), sto.columnOffset(), sto.rowSize(), sto.columnSize());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java
deleted file mode 100644
index 1f7b008..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * 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.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.storage.matrix.PivotedMatrixStorage;
-import org.apache.ignite.math.impls.vector.PivotedVectorView;
-
-/**
- * Pivoted (index mapped) view over another matrix implementation.
- */
-public class PivotedMatrixView extends AbstractMatrix {
- /** Pivoted matrix. */
- private Matrix mtx;
-
- /**
- *
- */
- public PivotedMatrixView() {
- // No-op.
- }
-
- /**
- * @param mtx
- * @param rowPivot
- * @param colPivot
- */
- public PivotedMatrixView(Matrix mtx, int[] rowPivot, int[] colPivot) {
- super(new PivotedMatrixStorage(mtx == null ? null : mtx.getStorage(), rowPivot, colPivot));
-
- this.mtx = mtx;
- }
-
- /**
- * @param mtx
- */
- public PivotedMatrixView(Matrix mtx) {
- super(new PivotedMatrixStorage(mtx == null ? null : mtx.getStorage()));
-
- this.mtx = mtx;
- }
-
- /**
- * @param mtx
- * @param pivot
- */
- public PivotedMatrixView(Matrix mtx, int[] pivot) {
- super(new PivotedMatrixStorage(mtx == null ? null : mtx.getStorage(), pivot));
-
- this.mtx = mtx;
- }
-
- /**
- * Swaps indexes {@code i} and {@code j} for both both row and column.
- *
- * @param i First index to swap.
- * @param j Second index to swap.
- */
- public Matrix swap(int i, int j) {
- swapRows(i, j);
- swapColumns(i, j);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix swapRows(int i, int j) {
- if (i < 0 || i >= storage().rowPivot().length)
- throw new IndexException(i);
- if (j < 0 || j >= storage().rowPivot().length)
- throw new IndexException(j);
-
- storage().swapRows(i, j);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix swapColumns(int i, int j) {
- if (i < 0 || i >= storage().columnPivot().length)
- throw new IndexException(i);
- if (j < 0 || j >= storage().columnPivot().length)
- throw new IndexException(j);
-
- storage().swapColumns(i, j);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewRow(int row) {
- return new PivotedVectorView(
- mtx.viewRow(storage().rowPivot()[row]),
- storage().columnPivot(),
- storage().columnUnpivot()
- );
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewColumn(int col) {
- return new PivotedVectorView(
- mtx.viewColumn(storage().columnPivot()[col]),
- storage().rowPivot(),
- storage().rowUnpivot()
- );
- }
-
- /**
- *
- *
- */
- public Matrix getBaseMatrix() {
- return mtx;
- }
-
- /**
- *
- *
- */
- public int[] rowPivot() {
- return storage().rowPivot();
- }
-
- /**
- *
- *
- */
- public int[] columnPivot() {
- return storage().columnPivot();
- }
-
- /**
- * @param i
- */
- public int rowPivot(int i) {
- return storage().rowPivot()[i];
- }
-
- /**
- * @param i
- */
- public int columnPivot(int i) {
- return storage().columnPivot()[i];
- }
-
- /**
- * @param i
- */
- public int rowUnpivot(int i) {
- return storage().rowUnpivot()[i];
- }
-
- /**
- * @param i
- */
- public int columnUnpivot(int i) {
- return storage().columnUnpivot()[i];
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeObject(mtx);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- mtx = (Matrix)in.readObject();
- }
-
- /**
- *
- *
- */
- private PivotedMatrixStorage storage() {
- return (PivotedMatrixStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- return new PivotedMatrixView(mtx, storage().rowPivot(), storage().columnPivot());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + mtx.hashCode();
- res = res * 37 + getStorage().hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- PivotedMatrixView that = (PivotedMatrixView)o;
-
- MatrixStorage sto = storage();
-
- return mtx.equals(that.mtx) && sto.equals(that.storage());
- }
-}
[09/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java
new file mode 100644
index 0000000..ca11e81
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/AbstractMatrix.java
@@ -0,0 +1,880 @@
+/*
+ * 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.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.decompositions.LUDecomposition;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.apache.ignite.math.exceptions.ColumnIndexException;
+import org.apache.ignite.math.exceptions.RowIndexException;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.functions.IgniteBiFunction;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.functions.IntIntToDoubleFunction;
+import org.apache.ignite.math.impls.vector.MatrixVectorView;
+
+/**
+ * This class provides a helper implementation of the {@link Matrix}
+ * interface to minimize the effort required to implement it.
+ * Subclasses may override some of the implemented methods if a more
+ * specific or optimized implementation is desirable.
+ *
+ * TODO: add row/column optimization.
+ */
+public abstract class AbstractMatrix implements Matrix {
+ // Stochastic sparsity analysis.
+ /** */
+ private static final double Z95 = 1.959964;
+ /** */
+ private static final double Z80 = 1.281552;
+ /** */
+ private static final int MAX_SAMPLES = 500;
+ /** */
+ private static final int MIN_SAMPLES = 15;
+
+ /** Cached minimum element. */
+ private Element minElm;
+ /** Cached maximum element. */
+ private Element maxElm = null;
+
+ /** Matrix storage implementation. */
+ private MatrixStorage sto;
+
+ /** Meta attributes storage. */
+ private Map<String, Object> meta = new HashMap<>();
+
+ /** Matrix's GUID. */
+ private IgniteUuid guid = IgniteUuid.randomUuid();
+
+ /**
+ * @param sto Backing {@link MatrixStorage}.
+ */
+ public AbstractMatrix(MatrixStorage sto) {
+ this.sto = sto;
+ }
+
+ /**
+ *
+ */
+ public AbstractMatrix() {
+ // No-op.
+ }
+
+ /**
+ * @param sto Backing {@link MatrixStorage}.
+ */
+ protected void setStorage(MatrixStorage sto) {
+ assert sto != null;
+
+ this.sto = sto;
+ }
+
+ /**
+ * @param row Row index in the matrix.
+ * @param col Column index in the matrix.
+ * @param v Value to set.
+ */
+ protected void storageSet(int row, int col, double v) {
+ sto.set(row, col, v);
+
+ // Reset cached values.
+ minElm = maxElm = null;
+ }
+
+ /**
+ * @param row Row index in the matrix.
+ * @param col Column index in the matrix.
+ */
+ protected double storageGet(int row, int col) {
+ return sto.get(row, col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element maxElement() {
+ if (maxElm == null) {
+ double max = Double.NEGATIVE_INFINITY;
+ int row = 0, col = 0;
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++) {
+ double d = storageGet(x, y);
+
+ if (d > max) {
+ max = d;
+ row = x;
+ col = y;
+ }
+ }
+
+ maxElm = mkElement(row, col);
+ }
+
+ return maxElm;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element minElement() {
+ if (minElm == null) {
+ double min = Double.MAX_VALUE;
+ int row = 0, col = 0;
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++) {
+ double d = storageGet(x, y);
+
+ if (d < min) {
+ min = d;
+ row = x;
+ col = y;
+ }
+ }
+
+ minElm = mkElement(row, col);
+ }
+
+ return minElm;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxValue() {
+ return maxElement().get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double minValue() {
+ return minElement().get();
+ }
+
+ /**
+ * @param row Row index in the matrix.
+ * @param col Column index in the matrix.
+ */
+ private Element mkElement(int row, int col) {
+ return new Element() {
+ /** {@inheritDoc} */
+ @Override public double get() {
+ return storageGet(row, col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int row() {
+ return row;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int column() {
+ return col;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(double d) {
+ storageSet(row, col, d);
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @Override public Element getElement(int row, int col) {
+ return mkElement(row, col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix swapRows(int row1, int row2) {
+ checkRowIndex(row1);
+ checkRowIndex(row2);
+
+ int cols = columnSize();
+
+ for (int y = 0; y < cols; y++) {
+ double v = getX(row1, y);
+
+ setX(row1, y, getX(row2, y));
+ setX(row2, y, v);
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix swapColumns(int col1, int col2) {
+ checkColumnIndex(col1);
+ checkColumnIndex(col2);
+
+ int rows = rowSize();
+
+ for (int x = 0; x < rows; x++) {
+ double v = getX(x, col1);
+
+ setX(x, col1, getX(x, col2));
+ setX(x, col2, v);
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public MatrixStorage getStorage() {
+ return sto;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return sto.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return sto.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return sto.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return sto.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return sto.isArrayBased();
+ }
+
+ /**
+ * Check row index bounds.
+ *
+ * @param row Row index.
+ */
+ private void checkRowIndex(int row) {
+ if (row < 0 || row >= rowSize())
+ throw new RowIndexException(row);
+ }
+
+ /**
+ * Check column index bounds.
+ *
+ * @param col Column index.
+ */
+ private void checkColumnIndex(int col) {
+ if (col < 0 || col >= columnSize())
+ throw new ColumnIndexException(col);
+ }
+
+ /**
+ * Check column and row index bounds.
+ *
+ * @param row Row index.
+ * @param col Column index.
+ */
+ protected void checkIndex(int row, int col) {
+ checkRowIndex(row);
+ checkColumnIndex(col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(sto);
+ out.writeObject(meta);
+ out.writeObject(guid);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Map<String, Object> getMetaStorage() {
+ return meta;
+ }
+
+ /** {@inheritDoc} */
+ @SuppressWarnings("unchecked")
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ sto = (MatrixStorage)in.readObject();
+ meta = (Map<String, Object>)in.readObject();
+ guid = (IgniteUuid)in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assign(double val) {
+ if (sto.isArrayBased())
+ for (double[] column : sto.data())
+ Arrays.fill(column, val);
+ else {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ storageSet(x, y, val);
+ }
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assign(IntIntToDoubleFunction fun) {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ storageSet(x, y, fun.apply(x, y));
+
+ return this;
+ }
+
+ /** */
+ private void checkCardinality(Matrix mtx) {
+ checkCardinality(mtx.rowSize(), mtx.columnSize());
+ }
+
+ /** */
+ private void checkCardinality(int rows, int cols) {
+ if (rows != rowSize())
+ throw new CardinalityException(rowSize(), rows);
+
+ if (cols != columnSize())
+ throw new CardinalityException(columnSize(), cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assign(double[][] vals) {
+ checkCardinality(vals.length, vals[0].length);
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ storageSet(x, y, vals[x][y]);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assign(Matrix mtx) {
+ checkCardinality(mtx);
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ storageSet(x, y, mtx.getX(x, y));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix map(IgniteDoubleFunction<Double> fun) {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ storageSet(x, y, fun.apply(storageGet(x, y)));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix map(Matrix mtx, IgniteBiFunction<Double, Double, Double> fun) {
+ checkCardinality(mtx);
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ storageSet(x, y, fun.apply(storageGet(x, y), mtx.getX(x, y)));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assignColumn(int col, org.apache.ignite.math.Vector vec) {
+ checkColumnIndex(col);
+
+ int rows = rowSize();
+
+ for (int x = 0; x < rows; x++)
+ storageSet(x, col, vec.getX(x));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assignRow(int row, Vector vec) {
+ checkRowIndex(row);
+
+ int cols = columnSize();
+
+ if (cols != vec.size())
+ throw new CardinalityException(cols, vec.size());
+
+ if (sto.isArrayBased() && vec.getStorage().isArrayBased())
+ System.arraycopy(vec.getStorage().data(), 0, sto.data()[row], 0, cols);
+ else
+ for (int y = 0; y < cols; y++)
+ storageSet(row, y, vec.getX(y));
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector foldRows(IgniteFunction<Vector, Double> fun) {
+ int rows = rowSize();
+
+ Vector vec = likeVector(rows);
+
+ for (int i = 0; i < rows; i++)
+ vec.setX(i, fun.apply(viewRow(i)));
+
+ return vec;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector foldColumns(IgniteFunction<Vector, Double> fun) {
+ int cols = columnSize();
+
+ Vector vec = likeVector(cols);
+
+ for (int i = 0; i < cols; i++)
+ vec.setX(i, fun.apply(viewColumn(i)));
+
+ return vec;
+ }
+
+ /** {@inheritDoc} */
+ @Override public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun,
+ T zeroVal) {
+ T res = zeroVal;
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ res = foldFun.apply(res, mapFun.apply(storageGet(x, y)));
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return sto.columnSize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return sto.rowSize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double determinant() {
+ //TODO: This decomposition should be cached
+ LUDecomposition dec = new LUDecomposition(this);
+ double res = dec.determinant();
+ dec.destroy();
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix inverse() {
+ if (rowSize() != columnSize())
+ throw new CardinalityException(rowSize(), columnSize());
+
+ //TODO: This decomposition should be cached
+ LUDecomposition dec = new LUDecomposition(this);
+
+ Matrix res = dec.solve(likeIdentity());
+ dec.destroy();
+
+ return res;
+ }
+
+ /** */
+ protected Matrix likeIdentity() {
+ int n = rowSize();
+ Matrix res = like(n, n);
+
+ for (int i = 0; i < n; i++)
+ res.setX(i, i, 1.0);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix divide(double d) {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ setX(x, y, getX(x, y) / d);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int row, int col) {
+ checkIndex(row, col);
+
+ return storageGet(row, col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double getX(int row, int col) {
+ return storageGet(row, col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix minus(Matrix mtx) {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ checkCardinality(rows, cols);
+
+ Matrix res = like(rows, cols);
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ res.setX(x, y, getX(x, y) - mtx.getX(x, y));
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix plus(double x) {
+ Matrix cp = copy();
+
+ cp.map(Functions.plus(x));
+
+ return cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix plus(Matrix mtx) {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ checkCardinality(rows, cols);
+
+ Matrix res = like(rows, cols);
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ res.setX(x, y, getX(x, y) + mtx.getX(x, y));
+
+ return res;
+
+ }
+
+ /** {@inheritDoc} */
+ @Override public IgniteUuid guid() {
+ return guid;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix set(int row, int col, double val) {
+ checkIndex(row, col);
+
+ storageSet(row, col, val);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix setRow(int row, double[] data) {
+ checkRowIndex(row);
+
+ int cols = columnSize();
+
+ if (cols != data.length)
+ throw new CardinalityException(cols, data.length);
+
+ if (sto.isArrayBased())
+ System.arraycopy(data, 0, sto.data()[row], 0, cols);
+ else
+ for (int y = 0; y < cols; y++)
+ setX(row, y, data[y]);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix setColumn(int col, double[] data) {
+ checkColumnIndex(col);
+
+ int rows = rowSize();
+
+ if (rows != data.length)
+ throw new CardinalityException(rows, data.length);
+
+ for (int x = 0; x < rows; x++)
+ setX(x, col, data[x]);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix setX(int row, int col, double val) {
+ storageSet(row, col, val);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix times(double x) {
+ Matrix cp = copy();
+
+ cp.map(Functions.mult(x));
+
+ return cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxAbsRowSumNorm() {
+ double max = 0.0;
+
+ int rows = rowSize();
+ int cols = columnSize();
+
+ for (int x = 0; x < rows; x++) {
+ double sum = 0;
+
+ for (int y = 0; y < cols; y++)
+ sum += Math.abs(getX(x, y));
+
+ if (sum > max)
+ max = sum;
+ }
+
+ return max;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector times(Vector vec) {
+ int cols = columnSize();
+
+ if (cols != vec.size())
+ throw new CardinalityException(cols, vec.size());
+
+ int rows = rowSize();
+
+ Vector res = likeVector(rows);
+
+ for (int x = 0; x < rows; x++)
+ res.setX(x, vec.dot(viewRow(x)));
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix times(Matrix mtx) {
+ int cols = columnSize();
+
+ if (cols != mtx.rowSize())
+ throw new CardinalityException(cols, mtx.rowSize());
+
+ int rows = rowSize();
+
+ int mtxCols = mtx.columnSize();
+
+ Matrix res = like(rows, mtxCols);
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < mtxCols; y++) {
+ double sum = 0.0;
+
+ for (int k = 0; k < cols; k++)
+ sum += getX(x, k) * mtx.getX(k, y);
+
+ res.setX(x, y, sum);
+ }
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ double sum = 0.0;
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ sum += getX(x, y);
+
+ return sum;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix transpose() {
+ int rows = rowSize();
+ int cols = columnSize();
+
+ Matrix mtx = like(cols, rows);
+
+ for (int x = 0; x < rows; x++)
+ for (int y = 0; y < cols; y++)
+ mtx.setX(y, x, getX(x, y));
+
+ return mtx;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean density(double threshold) {
+ assert threshold >= 0.0 && threshold <= 1.0;
+
+ int n = MIN_SAMPLES;
+ int rows = rowSize();
+ int cols = columnSize();
+
+ double mean = 0.0;
+ double pq = threshold * (1 - threshold);
+
+ Random rnd = new Random();
+
+ for (int i = 0; i < MIN_SAMPLES; i++)
+ if (getX(rnd.nextInt(rows), rnd.nextInt(cols)) != 0.0)
+ mean++;
+
+ mean /= MIN_SAMPLES;
+
+ double iv = Z80 * Math.sqrt(pq / n);
+
+ if (mean < threshold - iv)
+ return false; // Sparse.
+ else if (mean > threshold + iv)
+ return true; // Dense.
+
+ while (n < MAX_SAMPLES) {
+ // Determine upper bound we may need for 'n' to likely relinquish the uncertainty.
+ // Here, we use confidence interval formula but solved for 'n'.
+ double ivX = Math.max(Math.abs(threshold - mean), 1e-11);
+
+ double stdErr = ivX / Z80;
+ double nX = Math.min(Math.max((int)Math.ceil(pq / (stdErr * stdErr)), n), MAX_SAMPLES) - n;
+
+ if (nX < 1.0) // IMPL NOTE this can happen with threshold 1.0
+ nX = 1.0;
+
+ double meanNext = 0.0;
+
+ for (int i = 0; i < nX; i++)
+ if (getX(rnd.nextInt(rows), rnd.nextInt(cols)) != 0.0)
+ meanNext++;
+
+ mean = (n * mean + meanNext) / (n + nX);
+
+ n += nX;
+
+ // Are we good now?
+ iv = Z80 * Math.sqrt(pq / n);
+
+ if (mean < threshold - iv)
+ return false; // Sparse.
+ else if (mean > threshold + iv)
+ return true; // Dense.
+ }
+
+ return mean > threshold; // Dense if mean > threshold.
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix viewPart(int[] off, int[] size) {
+ return new MatrixView(this, off[0], off[1], size[0], size[1]);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix viewPart(int rowOff, int rows, int colOff, int cols) {
+ return viewPart(new int[] {rowOff, colOff}, new int[] {rows, cols});
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewRow(int row) {
+ return new MatrixVectorView(this, row, 0, 0, 1);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewColumn(int col) {
+ return new MatrixVectorView(this, 0, col, 1, 0);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewDiagonal() {
+ return new MatrixVectorView(this, 0, 0, 1, 1);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ Matrix cp = like(rowSize(), columnSize());
+
+ cp.assign(this);
+
+ return cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + guid.hashCode();
+ res = res * 37 + sto.hashCode();
+ res = res * 37 + meta.hashCode();
+
+ return res;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * We ignore guid's for comparisons.
+ */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ AbstractMatrix that = (AbstractMatrix)o;
+
+ MatrixStorage sto = getStorage();
+
+ return (sto != null ? sto.equals(that.getStorage()) : that.getStorage() == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java
new file mode 100644
index 0000000..8ce1192
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/CacheMatrix.java
@@ -0,0 +1,158 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixKeyMapper;
+import org.apache.ignite.math.ValueMapper;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.impls.CacheUtils;
+import org.apache.ignite.math.impls.storage.matrix.CacheMatrixStorage;
+
+/**
+ * Matrix based on existing cache and key and value mapping functions.
+ */
+public class CacheMatrix<K, V> extends AbstractMatrix {
+ /**
+ *
+ */
+ public CacheMatrix() {
+ // No-op.
+ }
+
+ /**
+ * Creates new matrix over existing cache.
+ *
+ * @param rows
+ * @param cols
+ * @param cache
+ * @param keyMapper
+ * @param valMapper
+ */
+ public CacheMatrix(
+ int rows,
+ int cols,
+ IgniteCache<K, V> cache,
+ MatrixKeyMapper<K> keyMapper,
+ ValueMapper<V> valMapper) {
+ assert rows > 0;
+ assert cols > 0;
+ assert cache != null;
+ assert keyMapper != null;
+ assert valMapper != null;
+
+ setStorage(new CacheMatrixStorage<>(rows, cols, cache, keyMapper, valMapper));
+ }
+
+ /**
+ *
+ *
+ */
+ @SuppressWarnings({"unchecked"})
+ private CacheMatrixStorage<K, V> storage() {
+ return (CacheMatrixStorage<K, V>)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Return the same matrix with updates values (broken contract).
+ *
+ * @param d
+ */
+ @Override public Matrix divide(double d) {
+ return mapOverValues((Double v) -> v / d);
+ }
+
+ /**
+ * Return the same matrix with updates values (broken contract).
+ *
+ * @param x
+ */
+ @Override public Matrix plus(double x) {
+ return mapOverValues((Double v) -> v + x);
+ }
+
+ /**
+ * Return the same matrix with updates values (broken contract).
+ *
+ * @param x
+ */
+ @Override public Matrix times(double x) {
+ return mapOverValues((Double v) -> v * x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assign(double val) {
+ return mapOverValues((Double v) -> val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix map(IgniteDoubleFunction<Double> fun) {
+ return mapOverValues(fun::apply);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ CacheMatrixStorage<K, V> sto = storage();
+
+ return CacheUtils.sum(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxValue() {
+ CacheMatrixStorage<K, V> sto = storage();
+
+ return CacheUtils.max(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double minValue() {
+ CacheMatrixStorage<K, V> sto = storage();
+
+ return CacheUtils.min(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
+ }
+
+ /**
+ * @param mapper
+ */
+ private Matrix mapOverValues(IgniteFunction<Double, Double> mapper) {
+ CacheMatrixStorage<K, V> sto = storage();
+
+ CacheUtils.map(sto.cache().getName(), sto.keyMapper(), sto.valueMapper(), mapper);
+
+ return this;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java
new file mode 100644
index 0000000..d5f8eca
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOffHeapMatrix.java
@@ -0,0 +1,90 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.storage.matrix.DenseOffHeapMatrixStorage;
+import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
+
+/**
+ * Dense local off-heap implementation of the {@link Matrix} interface.
+ */
+public class DenseLocalOffHeapMatrix extends AbstractMatrix {
+ /** */
+ public DenseLocalOffHeapMatrix() {
+ // No-op.
+ }
+
+ /**
+ * @param data Backing data array.
+ */
+ public DenseLocalOffHeapMatrix(double[][] data) {
+ assert data != null;
+
+ setStorage(new DenseOffHeapMatrixStorage(data));
+ }
+
+ /**
+ * @param rows Amount of rows in matrix.
+ * @param cols Amount of columns in matrix.
+ */
+ public DenseLocalOffHeapMatrix(int rows, int cols) {
+ assert rows > 0;
+ assert cols > 0;
+
+ setStorage(new DenseOffHeapMatrixStorage(rows, cols));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ DenseLocalOffHeapMatrix cp = new DenseLocalOffHeapMatrix(getStorage().rowSize(), getStorage().columnSize());
+
+ cp.assign(this);
+
+ return cp;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ return new DenseLocalOffHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ return new DenseLocalOffHeapVector(crd);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void destroy() {
+ getStorage().destroy();
+ }
+
+ /** {@inheritDoc} */
+ @Override protected Matrix likeIdentity() {
+ int n = rowSize();
+ Matrix res = like(n, n);
+
+ // IMPL NOTE as opposed to on-heap matrices this one isn't initialized with zeroes
+ for (int i = 0; i < n; i++)
+ for (int j = 0; j < n; j++)
+ res.setX(i, j, i == j ? 1.0 : 0.0);
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java
new file mode 100644
index 0000000..3cc3e4f
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DenseLocalOnHeapMatrix.java
@@ -0,0 +1,86 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.storage.matrix.ArrayMatrixStorage;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+
+/**
+ * Basic implementation for matrix.
+ *
+ * This is a trivial implementation for matrix assuming dense logic, local on-heap JVM storage
+ * based on <code>double[][]</code> array. It is only suitable for data sets where
+ * local, non-distributed execution is satisfactory and on-heap JVM storage is enough
+ * to keep the entire data set.
+ */
+public class DenseLocalOnHeapMatrix extends AbstractMatrix {
+ /**
+ *
+ */
+ public DenseLocalOnHeapMatrix() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in matrix.
+ * @param cols Amount of columns in matrix.
+ */
+ public DenseLocalOnHeapMatrix(int rows, int cols) {
+ assert rows > 0;
+ assert cols > 0;
+
+ setStorage(new ArrayMatrixStorage(rows, cols));
+ }
+
+ /**
+ * @param mtx Backing data array.
+ */
+ public DenseLocalOnHeapMatrix(double[][] mtx) {
+ assert mtx != null;
+
+ setStorage(new ArrayMatrixStorage(mtx));
+ }
+
+ /**
+ * @param orig Original matrix.
+ */
+ private DenseLocalOnHeapMatrix(DenseLocalOnHeapMatrix orig) {
+ assert orig != null;
+
+ setStorage(new ArrayMatrixStorage(orig.rowSize(), orig.columnSize()));
+
+ assign(orig);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ return new DenseLocalOnHeapMatrix(this);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ return new DenseLocalOnHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ return new DenseLocalOnHeapVector(crd);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java
new file mode 100644
index 0000000..0b1f97e
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/DiagonalMatrix.java
@@ -0,0 +1,101 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.storage.matrix.DiagonalMatrixStorage;
+import org.apache.ignite.math.impls.vector.ConstantVector;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+import org.apache.ignite.math.impls.vector.SingleElementVectorView;
+
+/**
+ * Implementation of diagonal view of the {@link Matrix}.
+ *
+ * <p>See also: <a href="https://en.wikipedia.org/wiki/Diagonal_matrix">Wikipedia article</a>.</p>
+ */
+public class DiagonalMatrix extends AbstractMatrix {
+ /**
+ *
+ */
+ public DiagonalMatrix() {
+ // No-op.
+ }
+
+ /**
+ * @param diagonal Backing {@link Vector}.
+ */
+ public DiagonalMatrix(Vector diagonal) {
+ super(new DiagonalMatrixStorage(diagonal));
+ }
+
+ /**
+ * @param mtx Backing {@link Matrix}.
+ */
+ public DiagonalMatrix(Matrix mtx) {
+ super(new DiagonalMatrixStorage(mtx == null ? null : mtx.viewDiagonal()));
+ }
+
+ /**
+ * @param vals Backing array of values at diagonal.
+ */
+ public DiagonalMatrix(double[] vals) {
+ super(new DiagonalMatrixStorage(new DenseLocalOnHeapVector(vals)));
+ }
+
+ /**
+ *
+ *
+ */
+ private DiagonalMatrixStorage storage() {
+ return (DiagonalMatrixStorage)getStorage();
+ }
+
+ /**
+ * @param size Size of diagonal.
+ * @param val Constant value at diagonal.
+ */
+ public DiagonalMatrix(int size, double val) {
+ super(new DiagonalMatrixStorage(new ConstantVector(size, val)));
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewRow(int row) {
+ return new SingleElementVectorView(storage().diagonal(), row);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewColumn(int col) {
+ return new SingleElementVectorView(storage().diagonal(), col);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ return new DiagonalMatrix(storage().diagonal());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ return storage().diagonal().likeMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ return storage().diagonal().like(crd);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java
new file mode 100644
index 0000000..b180b5b
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/FunctionMatrix.java
@@ -0,0 +1,95 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IntIntDoubleToVoidFunction;
+import org.apache.ignite.math.functions.IntIntToDoubleFunction;
+import org.apache.ignite.math.impls.storage.matrix.FunctionMatrixStorage;
+
+/**
+ * Implementation of {@link Matrix} that maps row and column index to {@link java.util.function} interfaces.
+ */
+public class FunctionMatrix extends AbstractMatrix {
+ /**
+ *
+ */
+ public FunctionMatrix() {
+ // No-op.
+ }
+
+ /**
+ * Creates read-write or read-only function matrix.
+ *
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param getFunc Function that returns value corresponding to given row and column index.
+ * @param setFunc Set function. If {@code null} - this will be a read-only matrix.
+ */
+ public FunctionMatrix(int rows, int cols, IntIntToDoubleFunction getFunc, IntIntDoubleToVoidFunction setFunc) {
+ assert rows > 0;
+ assert cols > 0;
+ assert getFunc != null;
+
+ setStorage(new FunctionMatrixStorage(rows, cols, getFunc, setFunc));
+ }
+
+ /**
+ * Creates read-only function matrix.
+ *
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param getFunc Function that returns value corresponding to given row and column index.
+ */
+ public FunctionMatrix(int rows, int cols, IntIntToDoubleFunction getFunc) {
+ assert rows > 0;
+ assert cols > 0;
+ assert getFunc != null;
+
+ setStorage(new FunctionMatrixStorage(rows, cols, getFunc));
+ }
+
+ /**
+ *
+ *
+ */
+ private FunctionMatrixStorage storage() {
+ return (FunctionMatrixStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ FunctionMatrixStorage sto = storage();
+
+ return new FunctionMatrix(sto.rowSize(), sto.columnSize(), sto.getFunction(), sto.setFunction());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ FunctionMatrixStorage sto = storage();
+
+ return new FunctionMatrix(rows, cols, sto.getFunction(), sto.setFunction());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java
new file mode 100644
index 0000000..7b04dde
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/MatrixView.java
@@ -0,0 +1,84 @@
+/*
+ * 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.matrix;
+
+import java.io.Externalizable;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.storage.matrix.MatrixDelegateStorage;
+
+/**
+ * Implements the rectangular view into the parent {@link Matrix}.
+ */
+public class MatrixView extends AbstractMatrix {
+ /**
+ * Constructor for {@link Externalizable} interface.
+ */
+ public MatrixView() {
+ // No-op.
+ }
+
+ /**
+ * @param parent Backing parent {@link Matrix}.
+ * @param rowOff Row offset to parent matrix.
+ * @param colOff Column offset to parent matrix.
+ * @param rows Amount of rows in the view.
+ * @param cols Amount of columns in the view.
+ */
+ public MatrixView(Matrix parent, int rowOff, int colOff, int rows, int cols) {
+ this(parent == null ? null : parent.getStorage(), rowOff, colOff, rows, cols);
+ }
+
+ /**
+ * @param sto Backing parent {@link MatrixStorage}.
+ * @param rowOff Row offset to parent storage.
+ * @param colOff Column offset to parent storage.
+ * @param rows Amount of rows in the view.
+ * @param cols Amount of columns in the view.
+ */
+ public MatrixView(MatrixStorage sto, int rowOff, int colOff, int rows, int cols) {
+ super(new MatrixDelegateStorage(sto, rowOff, colOff, rows, cols));
+ }
+
+ /**
+ *
+ *
+ */
+ private MatrixDelegateStorage storage() {
+ return (MatrixDelegateStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ MatrixDelegateStorage sto = storage();
+
+ return new MatrixView(sto.delegate(), sto.rowOffset(), sto.columnOffset(), sto.rowSize(), sto.columnSize());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java
new file mode 100644
index 0000000..1f7b008
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/PivotedMatrixView.java
@@ -0,0 +1,243 @@
+/*
+ * 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.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.storage.matrix.PivotedMatrixStorage;
+import org.apache.ignite.math.impls.vector.PivotedVectorView;
+
+/**
+ * Pivoted (index mapped) view over another matrix implementation.
+ */
+public class PivotedMatrixView extends AbstractMatrix {
+ /** Pivoted matrix. */
+ private Matrix mtx;
+
+ /**
+ *
+ */
+ public PivotedMatrixView() {
+ // No-op.
+ }
+
+ /**
+ * @param mtx
+ * @param rowPivot
+ * @param colPivot
+ */
+ public PivotedMatrixView(Matrix mtx, int[] rowPivot, int[] colPivot) {
+ super(new PivotedMatrixStorage(mtx == null ? null : mtx.getStorage(), rowPivot, colPivot));
+
+ this.mtx = mtx;
+ }
+
+ /**
+ * @param mtx
+ */
+ public PivotedMatrixView(Matrix mtx) {
+ super(new PivotedMatrixStorage(mtx == null ? null : mtx.getStorage()));
+
+ this.mtx = mtx;
+ }
+
+ /**
+ * @param mtx
+ * @param pivot
+ */
+ public PivotedMatrixView(Matrix mtx, int[] pivot) {
+ super(new PivotedMatrixStorage(mtx == null ? null : mtx.getStorage(), pivot));
+
+ this.mtx = mtx;
+ }
+
+ /**
+ * Swaps indexes {@code i} and {@code j} for both both row and column.
+ *
+ * @param i First index to swap.
+ * @param j Second index to swap.
+ */
+ public Matrix swap(int i, int j) {
+ swapRows(i, j);
+ swapColumns(i, j);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix swapRows(int i, int j) {
+ if (i < 0 || i >= storage().rowPivot().length)
+ throw new IndexException(i);
+ if (j < 0 || j >= storage().rowPivot().length)
+ throw new IndexException(j);
+
+ storage().swapRows(i, j);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix swapColumns(int i, int j) {
+ if (i < 0 || i >= storage().columnPivot().length)
+ throw new IndexException(i);
+ if (j < 0 || j >= storage().columnPivot().length)
+ throw new IndexException(j);
+
+ storage().swapColumns(i, j);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewRow(int row) {
+ return new PivotedVectorView(
+ mtx.viewRow(storage().rowPivot()[row]),
+ storage().columnPivot(),
+ storage().columnUnpivot()
+ );
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector viewColumn(int col) {
+ return new PivotedVectorView(
+ mtx.viewColumn(storage().columnPivot()[col]),
+ storage().rowPivot(),
+ storage().rowUnpivot()
+ );
+ }
+
+ /**
+ *
+ *
+ */
+ public Matrix getBaseMatrix() {
+ return mtx;
+ }
+
+ /**
+ *
+ *
+ */
+ public int[] rowPivot() {
+ return storage().rowPivot();
+ }
+
+ /**
+ *
+ *
+ */
+ public int[] columnPivot() {
+ return storage().columnPivot();
+ }
+
+ /**
+ * @param i
+ */
+ public int rowPivot(int i) {
+ return storage().rowPivot()[i];
+ }
+
+ /**
+ * @param i
+ */
+ public int columnPivot(int i) {
+ return storage().columnPivot()[i];
+ }
+
+ /**
+ * @param i
+ */
+ public int rowUnpivot(int i) {
+ return storage().rowUnpivot()[i];
+ }
+
+ /**
+ * @param i
+ */
+ public int columnUnpivot(int i) {
+ return storage().columnUnpivot()[i];
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeObject(mtx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ mtx = (Matrix)in.readObject();
+ }
+
+ /**
+ *
+ *
+ */
+ private PivotedMatrixStorage storage() {
+ return (PivotedMatrixStorage)getStorage();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ return new PivotedMatrixView(mtx, storage().rowPivot(), storage().columnPivot());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + mtx.hashCode();
+ res = res * 37 + getStorage().hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ PivotedMatrixView that = (PivotedMatrixView)o;
+
+ MatrixStorage sto = storage();
+
+ return mtx.equals(that.mtx) && sto.equals(that.storage());
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java
new file mode 100644
index 0000000..2c3dcb2
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java
@@ -0,0 +1,97 @@
+/*
+ * 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.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.storage.matrix.RandomMatrixStorage;
+import org.apache.ignite.math.impls.vector.RandomVector;
+
+/**
+ * Implementation of {@link Matrix} with random values in the elements.
+ */
+public class RandomMatrix extends AbstractMatrix {
+ /** Whether fast hash is used, see {@link RandomMatrixStorage}. */
+ private boolean fastHash;
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param fastHash Whether fast hash is used.
+ */
+ private MatrixStorage mkStorage(int rows, int cols, boolean fastHash) {
+ this.fastHash = fastHash;
+
+ return new RandomMatrixStorage(rows, cols, fastHash);
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param fastHash Whether fast hash is used.
+ */
+ public RandomMatrix(int rows, int cols, boolean fastHash) {
+ setStorage(mkStorage(rows, cols, fastHash));
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ */
+ public RandomMatrix(int rows, int cols) {
+ this(rows, cols, true);
+ }
+
+ /** */
+ public RandomMatrix() {
+ // No-op.
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ return new RandomMatrix(rowSize(), columnSize(), fastHash);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ return new RandomMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ return new RandomVector(crd);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeBoolean(fastHash);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ fastHash = in.readBoolean();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java
new file mode 100644
index 0000000..5c40d70
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java
@@ -0,0 +1,155 @@
+// @java.file.header
+
+/* _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteDoubleFunction;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.impls.CacheUtils;
+import org.apache.ignite.math.impls.storage.matrix.SparseDistributedMatrixStorage;
+
+/**
+ * Sparse distributed matrix implementation based on data grid.
+ *
+ * Unlike {@link CacheMatrix} that is based on existing cache, this implementation creates distributed
+ * cache internally and doesn't rely on pre-existing cache.
+ *
+ * You also need to call {@link #destroy()} to remove the underlying cache when you no longer need this
+ * matrix.
+ *
+ * <b>Currently fold supports only commutative operations.<b/>
+ */
+public class SparseDistributedMatrix extends AbstractMatrix implements StorageConstants {
+ /**
+ *
+ */
+ public SparseDistributedMatrix() {
+ // No-op.
+ }
+
+ /**
+ * @param rows
+ * @param cols
+ * @param stoMode
+ * @param acsMode
+ */
+ public SparseDistributedMatrix(int rows, int cols, int stoMode, int acsMode) {
+ assert rows > 0;
+ assert cols > 0;
+ assertAccessMode(acsMode);
+ assertStorageMode(stoMode);
+
+ setStorage(new SparseDistributedMatrixStorage(rows, cols, stoMode, acsMode));
+ }
+
+ /**
+ *
+ *
+ */
+ private SparseDistributedMatrixStorage storage() {
+ return (SparseDistributedMatrixStorage)getStorage();
+ }
+
+ /**
+ * Return the same matrix with updates values (broken contract).
+ *
+ * @param d
+ */
+ @Override public Matrix divide(double d) {
+ return mapOverValues((Double v) -> v / d);
+ }
+
+ /**
+ * Return the same matrix with updates values (broken contract).
+ *
+ * @param x
+ */
+ @Override public Matrix plus(double x) {
+ return mapOverValues((Double v) -> v + x);
+ }
+
+ /**
+ * Return the same matrix with updates values (broken contract).
+ *
+ * @param x
+ */
+ @Override public Matrix times(double x) {
+ return mapOverValues((Double v) -> v * x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix assign(double val) {
+ return mapOverValues((Double v) -> val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix map(IgniteDoubleFunction<Double> fun) {
+ return mapOverValues(fun::apply);
+ }
+
+ /**
+ * @param mapper
+ */
+ private Matrix mapOverValues(IgniteFunction<Double, Double> mapper) {
+ CacheUtils.sparseMap(storage().cache().getName(), mapper);
+
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double sum() {
+ return CacheUtils.sparseSum(storage().cache().getName());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double maxValue() {
+ return CacheUtils.sparseMax(storage().cache().getName());
+ }
+
+ /** {@inheritDoc} */
+ @Override public double minValue() {
+ return CacheUtils.sparseMin(storage().cache().getName());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java
new file mode 100644
index 0000000..cb08939
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java
@@ -0,0 +1,72 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.storage.matrix.SparseLocalOnHeapMatrixStorage;
+import org.apache.ignite.math.impls.vector.SparseLocalVector;
+
+/**
+ * Sparse local onheap matrix with {@link SparseLocalVector} as rows.
+ */
+public class SparseLocalOnHeapMatrix extends AbstractMatrix implements StorageConstants {
+ /**
+ *
+ */
+ public SparseLocalOnHeapMatrix() {
+ // No-op.
+ }
+
+ /**
+ * Construct new {@link SparseLocalOnHeapMatrix}.
+ *
+ * By default storage sets in row optimized mode and in random access mode.
+ */
+ public SparseLocalOnHeapMatrix(int rows, int cols) {
+ setStorage(mkStorage(rows, cols));
+ }
+
+ /**
+ * Create new {@link SparseLocalOnHeapMatrixStorage}.
+ */
+ private MatrixStorage mkStorage(int rows, int cols) {
+ return new SparseLocalOnHeapMatrixStorage(rows, cols, StorageConstants.RANDOM_ACCESS_MODE, StorageConstants.ROW_STORAGE_MODE);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ return new SparseLocalOnHeapMatrix(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ return new SparseLocalVector(crd, StorageConstants.RANDOM_ACCESS_MODE);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ Matrix cp = like(rowSize(), columnSize());
+
+ cp.assign(this);
+
+ return cp;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java
new file mode 100644
index 0000000..9da909b
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java
@@ -0,0 +1,84 @@
+/*
+ * 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.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.impls.storage.matrix.MatrixDelegateStorage;
+
+/**
+ * Implements transposed view of the parent {@link Matrix}.
+ */
+public class TransposedMatrixView extends AbstractMatrix {
+ /** */
+ public TransposedMatrixView() {
+ //No-op.
+ }
+
+ /**
+ * @param mtx Parent matrix.
+ */
+ public TransposedMatrixView(Matrix mtx) {
+ this(mtx == null ? null : mtx.getStorage());
+ }
+
+ /** */
+ private TransposedMatrixView(MatrixStorage sto) {
+ super(new MatrixDelegateStorage(sto, 0, 0,
+ sto == null ? 0 : sto.rowSize(), sto == null ? 0 : sto.columnSize()));
+ }
+
+ /** {@inheritDoc} */
+ @Override protected void storageSet(int row, int col, double v) {
+ super.storageSet(col, row, v);
+ }
+
+ /** {@inheritDoc} */
+ @Override protected double storageGet(int row, int col) {
+ return super.storageGet(col, row);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return getStorage().columnSize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return getStorage().rowSize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ MatrixDelegateStorage sto = (MatrixDelegateStorage)getStorage();
+
+ return new TransposedMatrixView(sto.delegate());
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ throw new UnsupportedOperationException();
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java
new file mode 100644
index 0000000..75d7532
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/matrix/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 several matrix implementations.
+ */
+package org.apache.ignite.math.impls.matrix;
\ 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/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/package-info.java
new file mode 100644
index 0000000..f1b2e36
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/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 specific implementations for core algebra.
+ */
+package org.apache.ignite.math.impls;
\ 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/storage/matrix/ArrayMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java
new file mode 100644
index 0000000..eb65b1d
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java
@@ -0,0 +1,161 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import org.apache.ignite.math.MatrixStorage;
+
+/**
+ * Array based {@link MatrixStorage} implementation.
+ */
+public class ArrayMatrixStorage implements MatrixStorage {
+ /** Backing data array. */
+ private double[][] data;
+ /** Amount of rows in the matrix. */
+ private int rows;
+ /** Amount of columns in the matrix. */
+ private int cols;
+
+ /**
+ *
+ */
+ public ArrayMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ */
+ public ArrayMatrixStorage(int rows, int cols) {
+ assert rows > 0;
+ assert cols > 0;
+
+ this.data = new double[rows][cols];
+ this.rows = rows;
+ this.cols = cols;
+ }
+
+ /**
+ * @param data Backing data array.
+ */
+ public ArrayMatrixStorage(double[][] data) {
+ assert data != null;
+ assert data[0] != null;
+
+ this.data = data;
+ this.rows = data.length;
+ this.cols = data[0].length;
+
+ assert rows > 0;
+ assert cols > 0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return data[x][y];
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ data[x][y] = v;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[][] data() {
+ return data;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+
+ out.writeObject(data);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+
+ data = (double[][])in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res += res * 37 + rows;
+ res += res * 37 + cols;
+ res += res * 37 + Arrays.deepHashCode(data);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ ArrayMatrixStorage that = (ArrayMatrixStorage)o;
+
+ return Arrays.deepEquals(data, that.data);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java
new file mode 100644
index 0000000..7aefa2c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java
@@ -0,0 +1,180 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.math.MatrixKeyMapper;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.ValueMapper;
+
+/**
+ * Matrix storage based on arbitrary cache and key and value mapping functions.
+ */
+public class CacheMatrixStorage<K, V> implements MatrixStorage {
+ /** */ private int rows;
+ /** */ private int cols;
+ /** */ private IgniteCache<K, V> cache;
+ /** */ private MatrixKeyMapper<K> keyMapper;
+ /** */ private ValueMapper<V> valMapper;
+
+ /**
+ *
+ */
+ public CacheMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows
+ * @param cols
+ * @param cache
+ * @param keyMapper
+ * @param valMapper
+ */
+ public CacheMatrixStorage(int rows, int cols, IgniteCache<K, V> cache, MatrixKeyMapper<K> keyMapper,
+ ValueMapper<V> valMapper) {
+ assert rows > 0;
+ assert cols > 0;
+ assert cache != null;
+ assert keyMapper != null;
+ assert valMapper != null;
+
+ this.rows = rows;
+ this.cols = cols;
+ this.cache = cache;
+ this.keyMapper = keyMapper;
+ this.valMapper = valMapper;
+ }
+
+ /**
+ * @return Ignite cache.
+ */
+ public IgniteCache<K, V> cache() {
+ return cache;
+ }
+
+ /**
+ * @return Key mapper.
+ */
+ public MatrixKeyMapper<K> keyMapper() {
+ return keyMapper;
+ }
+
+ /**
+ * @return Value mapper.
+ */
+ public ValueMapper<V> valueMapper() {
+ return valMapper;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return valMapper.toDouble(cache.get(keyMapper.apply(x, y)));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ cache.put(keyMapper.apply(x, y), valMapper.fromDouble(v));
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+ out.writeUTF(cache.getName());
+ out.writeObject(keyMapper);
+ out.writeObject(valMapper);
+ }
+
+ /** {@inheritDoc} */
+ @SuppressWarnings({"unchecked"})
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+ cache = Ignition.localIgnite().getOrCreateCache(in.readUTF());
+ keyMapper = (MatrixKeyMapper<K>)in.readObject();
+ valMapper = (ValueMapper<V>)in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + rows;
+ res = res * 37 + cols;
+ res = res * 37 + cache.hashCode();
+ res = res * 37 + keyMapper.hashCode();
+ res = res * 37 + valMapper.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ CacheMatrixStorage that = (CacheMatrixStorage)o;
+
+ return (cache != null ? cache.equals(that.cache) : that.cache == null) &&
+ (keyMapper != null ? keyMapper.equals(that.keyMapper) : that.keyMapper == null) &&
+ (valMapper != null ? valMapper.equals(that.valMapper) : that.valMapper == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java
new file mode 100644
index 0000000..6695bc2
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java
@@ -0,0 +1,197 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.internal.util.GridUnsafe;
+import org.apache.ignite.math.MatrixStorage;
+
+/**
+ * Local, dense off-heap matrix storage.
+ */
+public class DenseOffHeapMatrixStorage implements MatrixStorage {
+ /** */ private int rows;
+ /** */ private int cols;
+ /** */ private transient long ptr;
+ //TODO: temp solution.
+ /** */ private int ptrInitHash;
+
+ /** */
+ public DenseOffHeapMatrixStorage() {
+ // No-op.
+ }
+
+ /** */
+ public DenseOffHeapMatrixStorage(int rows, int cols) {
+ assert rows > 0;
+ assert cols > 0;
+
+ this.rows = rows;
+ this.cols = cols;
+
+ allocateMemory(rows, cols);
+ }
+
+ /** */
+ public DenseOffHeapMatrixStorage(double[][] data) {
+ assert data != null;
+ assert data[0] != null;
+
+ this.rows = data.length;
+ this.cols = data[0].length;
+
+ assert rows > 0;
+ assert cols > 0;
+
+ allocateMemory(rows, cols);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ set(i, j, data[i][j]);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return GridUnsafe.getDouble(pointerOffset(x, y));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ GridUnsafe.putDouble(pointerOffset(x, y), v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[][] data() {
+ return null;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+ out.writeInt(ptrInitHash);
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ out.writeDouble(get(i, j));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+
+ allocateMemory(rows, cols);
+
+ ptrInitHash = in.readInt();
+
+ for (int i = 0; i < rows; i++)
+ for (int j = 0; j < cols; j++)
+ set(i, j, in.readDouble());
+ }
+
+ /** {@inheritDoc} */
+ @Override public void destroy() {
+ GridUnsafe.freeMemory(ptr);
+ }
+
+ /** {@inheritDoc} */
+ private long pointerOffset(int x, int y) {
+ return ptr + x * cols * Double.BYTES + y * Double.BYTES;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ return obj != null &&
+ getClass().equals(obj.getClass()) &&
+ (rows == ((DenseOffHeapMatrixStorage)obj).rows) &&
+ (cols == ((DenseOffHeapMatrixStorage)obj).cols) &&
+ (rows == 0 || cols == 0 || ptr == ((DenseOffHeapMatrixStorage)obj).ptr || isMemoryEquals((DenseOffHeapMatrixStorage)obj));
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + rows;
+ res = res * 37 + cols;
+ res = res * 37 + ptrInitHash;
+
+ return res;
+ }
+
+ /** */
+ private boolean isMemoryEquals(DenseOffHeapMatrixStorage otherStorage) {
+ boolean res = true;
+
+ for (int i = 0; i < otherStorage.rows; i++) {
+ for (int j = 0; j < otherStorage.cols; j++) {
+ if (Double.compare(get(i, j), otherStorage.get(i, j)) != 0) {
+ res = false;
+ break;
+ }
+ }
+ }
+
+ return res;
+ }
+
+ /** */
+ private void allocateMemory(int rows, int cols) {
+ ptr = GridUnsafe.allocateMemory(rows * cols * Double.BYTES);
+
+ ptrInitHash = Long.hashCode(ptr);
+ }
+}
[19/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java
deleted file mode 100644
index 670deef..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.Ignition;
-import org.apache.ignite.math.ValueMapper;
-import org.apache.ignite.math.VectorKeyMapper;
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * Vector storage based on existing cache and index and value mapping functions.
- */
-public class CacheVectorStorage<K, V> implements VectorStorage {
- /** Storage size. */
- private int size;
- /** Key mapper. */
- private VectorKeyMapper<K> keyMapper;
- /** Value mapper. */
- private ValueMapper<V> valMapper;
- /** Underlying ignite cache. */
- private IgniteCache<K, V> cache;
-
- /**
- *
- */
- public CacheVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size
- * @param cache
- * @param keyMapper
- * @param valMapper
- */
- public CacheVectorStorage(int size, IgniteCache<K, V> cache, VectorKeyMapper<K> keyMapper,
- ValueMapper<V> valMapper) {
- assert size > 0;
- assert cache != null;
- assert keyMapper != null;
- assert valMapper != null;
-
- this.size = size;
- this.cache = cache;
- this.keyMapper = keyMapper;
- this.valMapper = valMapper;
- }
-
- /**
- *
- *
- */
- public IgniteCache<K, V> cache() {
- return cache;
- }
-
- /**
- *
- *
- */
- public VectorKeyMapper<K> keyMapper() {
- return keyMapper;
- }
-
- /**
- *
- *
- */
- public ValueMapper<V> valueMapper() {
- return valMapper;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return valMapper.toDouble(cache.get(keyMapper.apply(i)));
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- cache.put(keyMapper.apply(i), valMapper.fromDouble(v));
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(size);
- out.writeObject(keyMapper);
- out.writeObject(valMapper);
- out.writeUTF(cache.getName());
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- size = in.readInt();
- keyMapper = (VectorKeyMapper<K>)in.readObject();
- valMapper = (ValueMapper<V>)in.readObject();
- cache = Ignition.localIgnite().getOrCreateCache(in.readUTF());
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + size();
- res = res * 37 + keyMapper.hashCode();
- res = res * 37 + valMapper.hashCode();
- res = res * 37 + cache.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- CacheVectorStorage that = (CacheVectorStorage)obj;
-
- return size == that.size
- && (keyMapper != null ? keyMapper.getClass().equals(that.keyMapper.getClass()) : that.keyMapper == null)
- && (valMapper != null ? valMapper.getClass().equals(that.valMapper.getClass()) : that.valMapper == null)
- && (cache != null ? cache.equals(that.cache) : that.cache == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java
deleted file mode 100644
index ff5ab26..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * Constant read-only vector storage.
- */
-public class ConstantVectorStorage implements VectorStorage {
- /** */ private int size;
- /** */ private double val;
-
- /**
- *
- */
- public ConstantVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size Vector size.
- * @param val Value to set for vector elements.
- */
- public ConstantVectorStorage(int size, double val) {
- assert size > 0;
-
- this.size = size;
- this.val = val;
- }
-
- /**
- *
- *
- */
- public double constant() {
- return val;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return val;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- throw new UnsupportedOperationException("Can't set value into constant vector.");
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(size);
- out.writeDouble(val);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- size = in.readInt();
- val = in.readDouble();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + size;
- res = res * 37 + Double.hashCode(val);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- ConstantVectorStorage that = (ConstantVectorStorage)o;
-
- return size == that.size && val == that.val;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java
deleted file mode 100644
index aa6018c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * {@link VectorStorage} implementation that delegates to parent matrix.
- */
-public class DelegateVectorStorage implements VectorStorage {
- /** Parent vector storage. */
- private VectorStorage sto;
-
- /** Offset in the parent vector. */
- private int off;
-
- /** Size of the vector. */
- private int len;
-
- /**
- *
- */
- public DelegateVectorStorage() {
- // No-op.
- }
-
- /**
- * @param sto Vector storage to delegate to.
- * @param off Offset in the parent vector.
- * @param len Size of the vector.
- */
- public DelegateVectorStorage(VectorStorage sto, int off, int len) {
- assert sto != null;
- assert off >= 0;
- assert len > 0;
-
- this.sto = sto;
- this.off = off;
- this.len = len;
- }
-
- /** */
- public VectorStorage delegate() {
- return sto;
- }
-
- /** */
- public int offset() {
- return off;
- }
-
- /** */
- public int length() {
- return len;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return len;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return sto.get(off + i);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- sto.set(off + i, v);
- }
-
- /** {@inheritDoc} */
- @Override public double[] data() {
- return sto.data();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return sto.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return sto.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return sto.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return sto.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return sto.isArrayBased();
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(sto);
- out.writeInt(off);
- out.writeInt(len);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- sto = (VectorStorage)in.readObject();
- off = in.readInt();
- len = in.readInt();
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- DelegateVectorStorage that = (DelegateVectorStorage)o;
-
- return len == that.len && off == that.off && (sto != null ? sto.equals(that.sto) : that.sto == null);
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + off;
- res = res * 37 + len;
- res = res * 37 + sto.hashCode();
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java
deleted file mode 100644
index 2e7cdc9..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.stream.IntStream;
-import org.apache.ignite.internal.util.GridUnsafe;
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * Local, dense off-heap vector storage.
- */
-public class DenseLocalOffHeapVectorStorage implements VectorStorage {
- /** Vector size. */
- private int size;
-
- /** */
- private transient long ptr;
- //TODO: temp solution.
- /** */
- private int ptrInitHash;
-
- /**
- *
- */
- public DenseLocalOffHeapVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size Vector size.
- */
- public DenseLocalOffHeapVectorStorage(int size) {
- assert size > 0;
-
- this.size = size;
-
- allocateMemory(size);
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return GridUnsafe.getDouble(pointerOffset(i));
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- GridUnsafe.putDouble(pointerOffset(i), v);
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public double[] data() {
- return null;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(size);
- out.writeInt(ptrInitHash);
-
- for (int i = 0; i < size; i++)
- out.writeDouble(get(i));
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- size = in.readInt();
-
- allocateMemory(size);
-
- ptrInitHash = in.readInt();
-
- for (int i = 0; i < size; i++)
- set(i, in.readDouble());
- }
-
- /** {@inheritDoc} */
- @Override public void destroy() {
- GridUnsafe.freeMemory(ptr);
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + size;
- res = res * 37 + ptrInitHash;
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- DenseLocalOffHeapVectorStorage that = (DenseLocalOffHeapVectorStorage)o;
-
- return size == that.size && isMemoryEquals(that);
- }
-
- /** */
- private boolean isMemoryEquals(DenseLocalOffHeapVectorStorage otherStorage) {
- return IntStream.range(0, size).parallel().noneMatch(idx -> Double.compare(get(idx), otherStorage.get(idx)) != 0);
- }
-
- /**
- * Pointer offset for specific index.
- *
- * @param i Offset index.
- */
- private long pointerOffset(int i) {
- return ptr + i * Double.BYTES;
- }
-
- /** */
- private void allocateMemory(int size) {
- ptr = GridUnsafe.allocateMemory(size * Double.BYTES);
-
- ptrInitHash = Long.hashCode(ptr);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java
deleted file mode 100644
index df8fa12..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.functions.IntDoubleToVoidFunction;
-
-/**
- * Read-only or read-write function-based vector storage.
- */
-public class FunctionVectorStorage implements VectorStorage {
- /** */ private IgniteFunction<Integer, Double> getFunc;
- /** */ private IntDoubleToVoidFunction setFunc;
- /** */ private int size;
-
- /**
- *
- */
- public FunctionVectorStorage() {
- // No-op.
- }
-
- /**
- * Creates read-only or read-write storage.
- *
- * @param size Cardinality of this vector storage.
- * @param getFunc Get function.
- * @param setFunc Optional set function ({@code null} for read-only storage).
- */
- public FunctionVectorStorage(int size, IgniteFunction<Integer, Double> getFunc, IntDoubleToVoidFunction setFunc) {
- assert size > 0;
- assert getFunc != null; // At least get function is required.
-
- this.size = size;
- this.getFunc = getFunc;
- this.setFunc = setFunc;
- }
-
- /**
- *
- *
- */
- public IgniteFunction<Integer, Double> getFunction() {
- return getFunc;
- }
-
- /**
- *
- *
- */
- public IntDoubleToVoidFunction setFunction() {
- return setFunc;
- }
-
- /**
- * Creates read-only storage.
- *
- * @param size Cardinality of this vector storage.
- * @param getFunc Get function.
- */
- public FunctionVectorStorage(int size, IgniteFunction<Integer, Double> getFunc) {
- this(size, getFunc, null);
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return getFunc.apply(i);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- if (setFunc != null)
- setFunc.accept(i, v);
- else
- throw new UnsupportedOperationException("Cannot set into read-only vector.");
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(setFunc);
- out.writeObject(getFunc);
- out.writeInt(size);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- setFunc = (IntDoubleToVoidFunction)in.readObject();
- getFunc = (IgniteFunction<Integer, Double>)in.readObject();
- size = in.readInt();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java
deleted file mode 100644
index ece0003..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.IndexException;
-
-/**
- * Row, column or diagonal vector-based view of the matrix
- */
-public class MatrixVectorStorage implements VectorStorage {
- /** */ private Matrix parent;
-
- /** */ private int row;
- /** */ private int col;
-
- /** */ private int rowStride;
- /** */ private int colStride;
-
- /** */ private int size;
-
- /**
- *
- */
- public MatrixVectorStorage() {
- // No-op.
- }
-
- /**
- * @param parent
- * @param row
- * @param col
- * @param rowStride
- * @param colStride
- */
- public MatrixVectorStorage(Matrix parent, int row, int col, int rowStride, int colStride) {
- assert parent != null;
- assert rowStride >= 0;
- assert colStride >= 0;
- assert rowStride > 0 || colStride > 0;
-
- if (row < 0 || row >= parent.rowSize())
- throw new IndexException(row);
- if (col < 0 || col >= parent.columnSize())
- throw new IndexException(col);
-
- this.parent = parent;
-
- this.row = row;
- this.col = col;
-
- this.rowStride = rowStride;
- this.colStride = colStride;
-
- this.size = getSize();
- }
-
- /**
- *
- *
- */
- int row() {
- return row;
- }
-
- /**
- *
- *
- */
- int column() {
- return col;
- }
-
- /**
- *
- *
- */
- int rowStride() {
- return rowStride;
- }
-
- /**
- *
- *
- */
- int columnStride() {
- return colStride;
- }
-
- /**
- *
- *
- */
- private int getSize() {
- if (rowStride != 0 && colStride != 0) {
- int n1 = (parent.rowSize() - row) / rowStride;
- int n2 = (parent.columnSize() - col) / colStride;
-
- return Math.min(n1, n2);
- }
- else if (rowStride > 0)
- return (parent.rowSize() - row) / rowStride;
- else
- return (parent.columnSize() - col) / colStride;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return parent.get(row + i * rowStride, col + i * colStride);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- parent.set(row + i * rowStride, col + i * colStride, v);
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return parent.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return parent.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return parent.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return parent.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(parent);
- out.writeInt(row);
- out.writeInt(col);
- out.writeInt(rowStride);
- out.writeInt(colStride);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- parent = (Matrix)in.readObject();
- row = in.readInt();
- col = in.readInt();
- rowStride = in.readInt();
- colStride = in.readInt();
-
- size = getSize();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java
deleted file mode 100644
index f69e959..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * Pivoted (index mapped) view over another vector storage implementation.
- */
-public class PivotedVectorStorage implements VectorStorage {
- /** */ private VectorStorage sto;
-
- /** */ private int[] pivot;
- /** */ private int[] unpivot;
-
- /**
- * @param pivot Pivot array.
- */
- private static int[] reverse(int[] pivot) {
- int[] res = new int[pivot.length];
-
- for (int i = 0; i < pivot.length; i++)
- res[pivot[i]] = i;
-
- return res;
- }
-
- /**
- *
- *
- */
- public int[] pivot() {
- return pivot;
- }
-
- /**
- *
- *
- */
- public int[] unpivot() {
- return unpivot;
- }
-
- /**
- * @param sto Backing vector storage.
- * @param pivot Mapping from external index to internal.
- * @param unpivot Mapping from internal index to external.
- */
- public PivotedVectorStorage(VectorStorage sto, int[] pivot, int[] unpivot) {
- assert sto != null;
- assert pivot != null;
- assert unpivot != null;
-
- this.sto = sto;
- this.pivot = pivot;
- this.unpivot = unpivot;
- }
-
- /**
- * @param sto Backing vector storage.
- * @param pivot Mapping from external index to internal.
- */
- public PivotedVectorStorage(VectorStorage sto, int[] pivot) {
- this(sto, pivot, reverse(pivot));
- }
-
- /**
- *
- */
- public PivotedVectorStorage() {
- // No-op.
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return sto.size();
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return sto.get(pivot[i]);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- sto.set(pivot[i], v);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(sto);
- out.writeObject(pivot);
- out.writeObject(unpivot);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- sto = (VectorStorage)in.readObject();
- pivot = (int[])in.readObject();
- unpivot = (int[])in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return sto.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return sto.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return sto.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return sto.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return sto.isArrayBased();
- }
-
- /** {@inheritDoc} */
- @Override public double[] data() {
- return isArrayBased() ? sto.data() : null;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- PivotedVectorStorage that = (PivotedVectorStorage)o;
-
- return (sto != null ? sto.equals(that.sto) : that.sto == null) && Arrays.equals(pivot, that.pivot)
- && Arrays.equals(unpivot, that.unpivot);
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = sto != null ? sto.hashCode() : 0;
-
- res = 31 * res + Arrays.hashCode(pivot);
- res = 31 * res + Arrays.hashCode(unpivot);
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java
deleted file mode 100644
index 58f0fb4..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/RandomVectorStorage.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.nio.ByteBuffer;
-import java.util.Random;
-import org.apache.ignite.math.MurmurHash;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * {@link VectorStorage} implementation with random values in the vector elements.
- */
-public class RandomVectorStorage implements VectorStorage {
- /** */
- private static final long SCALE = 1L << 32;
- /** */
- private static final int PRIME = 104047;
-
- /** Random generation seed. */
- private int seed;
-
- /** Vector size. */
- private int size;
-
- /** Whether fast hash is used, in {@link #get(int)}. */
- private boolean fastHash;
-
- /** */
- public RandomVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size Size of the storage.
- * @param fastHash Whether or not to use fast hashing or Murmur hashing.
- */
- public RandomVectorStorage(int size, boolean fastHash) {
- assert size > 0;
-
- this.size = size;
- this.fastHash = fastHash;
-
- seed = new Random().nextInt();
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- if (!fastHash) {
- ByteBuffer buf = ByteBuffer.allocate(4);
-
- buf.putInt(i);
- buf.flip();
-
- return (MurmurHash.hash64A(buf, seed) & (SCALE - 1)) / (double)SCALE;
- }
- else
- // This isn't a fantastic random number generator, but it is just fine for random projections.
- return (((i * PRIME) & 8) * 0.25) - 1;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- throw new UnsupportedOperationException("Random vector storage is a read-only storage.");
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(size);
- out.writeInt(seed);
- out.writeBoolean(fastHash);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- size = in.readInt();
- seed = in.readInt();
- fastHash = in.readBoolean();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + Boolean.hashCode(fastHash);
- res = res * 37 + seed;
- res = res * 37 + size;
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- RandomVectorStorage that = (RandomVectorStorage)o;
-
- return size == that.size && seed == that.seed && fastHash == that.fastHash;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java
deleted file mode 100644
index c5a4350..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorDelegateStorage.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * Single value view storage over another vector.
- */
-public class SingleElementVectorDelegateStorage implements VectorStorage {
- /** */ private int idx;
- /** */ private Vector vec;
-
- /**
- *
- */
- public SingleElementVectorDelegateStorage() {
- // No-op.
- }
-
- /**
- * @param vec Parent vector.
- * @param idx Element index.
- */
- public SingleElementVectorDelegateStorage(Vector vec, int idx) {
- assert vec != null;
- assert idx >= 0;
-
- this.vec = vec;
- this.idx = idx;
- }
-
- /**
- *
- *
- */
- public int index() {
- return idx;
- }
-
- /**
- *
- *
- */
- public Vector delegate() {
- return vec;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return vec.size();
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return i == idx ? vec.get(i) : 0.0;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- if (i == idx)
- vec.set(i, v);
- else
- throw new UnsupportedOperationException("Can't set element outside of index: " + idx);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(vec);
- out.writeInt(idx);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- vec = (Vector)in.readObject();
- idx = in.readInt();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- SingleElementVectorDelegateStorage that = (SingleElementVectorDelegateStorage)o;
-
- return idx == that.idx && (vec != null ? vec.equals(that.vec) : that.vec == null);
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = idx;
-
- res = 31 * res + (vec != null ? vec.hashCode() : 0);
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java
deleted file mode 100644
index 3378817..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SingleElementVectorStorage.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * Vector storage holding a single non-zero value at some index.
- */
-public class SingleElementVectorStorage implements VectorStorage {
- /** */ private int idx;
- /** */ private double val;
- /** */ private int size;
-
- /**
- *
- */
- public SingleElementVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size Parent vector size.
- * @param idx Element index in the parent vector.
- * @param val Value of the element.
- */
- public SingleElementVectorStorage(int size, int idx, double val) {
- assert size > 0;
- assert idx >= 0;
-
- this.size = size;
- this.idx = idx;
- this.val = val;
- }
-
- /**
- *
- * @return Index of the element in the parent vector.
- */
- public int index() {
- return idx;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return i == idx ? val : 0.0;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- if (i == idx)
- val = v;
- else
- throw new UnsupportedOperationException("Can't set element outside of index: " + idx);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(size);
- out.writeInt(idx);
- out.writeDouble(val);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- size = in.readInt();
- idx = in.readInt();
- val = in.readDouble();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- SingleElementVectorStorage that = (SingleElementVectorStorage)o;
-
- return idx == that.idx && Double.compare(that.val, val) == 0 && size == that.size;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = idx;
- long temp = Double.doubleToLongBits(val);
-
- res = 31 * res + (int)(temp ^ (temp >>> 32));
- res = 31 * res + size;
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java
deleted file mode 100644
index 9b912cb..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOffHeapVectorStorage.java
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.nio.ByteBuffer;
-import org.apache.ignite.internal.util.offheap.GridOffHeapMap;
-import org.apache.ignite.internal.util.offheap.GridOffHeapMapFactory;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * {@link VectorStorage} implementation for {@link org.apache.ignite.math.impls.vector.SparseLocalOffHeapVector}.
- */
-public class SparseLocalOffHeapVectorStorage implements VectorStorage {
- /** Assume 10% density. */
- private static final int INIT_DENSITY = 10;
- /** Storage capacity. */
- private int size;
- /** Local off heap map. */
- private GridOffHeapMap gridOffHeapMap;
-
- /** */
- public SparseLocalOffHeapVectorStorage() {
- //No-op.
- }
-
- /** */
- public SparseLocalOffHeapVectorStorage(int cap) {
- assert cap > 0;
-
- gridOffHeapMap = GridOffHeapMapFactory.unsafeMap(cap / INIT_DENSITY);
- size = cap;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- byte[] bytes = gridOffHeapMap.get(hash(i), intToByteArray(i));
- return bytes == null ? 0 : ByteBuffer.wrap(bytes).getDouble();
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- if (v != 0.0)
- gridOffHeapMap.put(hash(i), intToByteArray(i), doubleToByteArray(v));
- else if (gridOffHeapMap.contains(hash(i), intToByteArray(i)))
- gridOffHeapMap.remove(hash(i), intToByteArray(i));
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- throw new UnsupportedOperationException(); // TODO: add externalization support.
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void destroy() {
- gridOffHeapMap.destruct();
- }
-
- /** */
- private int hash(int h) {
- // Apply base step of MurmurHash; see http://code.google.com/p/smhasher/
- // Despite two multiplies, this is often faster than others
- // with comparable bit-spread properties.
- h ^= h >>> 16;
- h *= 0x85ebca6b;
- h ^= h >>> 13;
- h *= 0xc2b2ae35;
-
- return (h >>> 16) ^ h;
- }
-
- /** */
- private byte[] intToByteArray(int val) {
- return new byte[] {
- (byte)(val >>> 24),
- (byte)(val >>> 16),
- (byte)(val >>> 8),
- (byte)val};
- }
-
- /** */
- private byte[] doubleToByteArray(double val) {
- long l = Double.doubleToRawLongBits(val);
- return new byte[] {
- (byte)((l >> 56) & 0xff),
- (byte)((l >> 48) & 0xff),
- (byte)((l >> 40) & 0xff),
- (byte)((l >> 32) & 0xff),
- (byte)((l >> 24) & 0xff),
- (byte)((l >> 16) & 0xff),
- (byte)((l >> 8) & 0xff),
- (byte)((l) & 0xff),
- };
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java
deleted file mode 100644
index b3a8a3c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/SparseLocalOnHeapVectorStorage.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * 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.storage.vector;
-
-import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
-import it.unimi.dsi.fastutil.ints.Int2DoubleRBTreeMap;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Map;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * Sparse, local, on-heap vector storage.
- */
-public class SparseLocalOnHeapVectorStorage implements VectorStorage, StorageConstants {
- /** */ private int size;
- /** */ private int acsMode;
-
- /** Actual map storage. */
- private Map<Integer, Double> sto;
-
- /**
- *
- */
- public SparseLocalOnHeapVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size Vector size.
- * @param acsMode Access mode.
- */
- public SparseLocalOnHeapVectorStorage(int size, int acsMode) {
- assert size > 0;
- assertAccessMode(acsMode);
-
- this.size = size;
- this.acsMode = acsMode;
-
- if (acsMode == SEQUENTIAL_ACCESS_MODE)
- sto = new Int2DoubleRBTreeMap();
- else
- sto = new Int2DoubleOpenHashMap();
- }
-
- /**
- *
- *
- */
- public int getAccessMode() {
- return acsMode;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return size;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return sto.getOrDefault(i, 0.0);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- if (v != 0.0)
- sto.put(i, v);
- else if (sto.containsKey(i))
- sto.remove(i);
-
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(size);
- out.writeInt(acsMode);
- out.writeObject(sto);
- }
-
- /** {@inheritDoc} */
- @SuppressWarnings({"unchecked"})
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- size = in.readInt();
- acsMode = in.readInt();
- sto = (Map<Integer, Double>)in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return acsMode == SEQUENTIAL_ACCESS_MODE;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- SparseLocalOnHeapVectorStorage that = (SparseLocalOnHeapVectorStorage)o;
-
- return size == that.size && acsMode == that.acsMode && (sto != null ? sto.equals(that.sto) : that.sto == null);
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = size;
-
- res = 31 * res + acsMode;
- res = 31 * res + (sto != null ? sto.hashCode() : 0);
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java
deleted file mode 100644
index a716e6a..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 specific implementations for vector storage models.
- */
-package org.apache.ignite.math.impls.storage.vector;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java
deleted file mode 100644
index 58c583a..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractReadOnlyVector.java
+++ /dev/null
@@ -1,108 +0,0 @@
-package org.apache.ignite.math.impls.vector;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.impls.matrix.FunctionMatrix;
-
-/**
- * This class provides a helper implementation of the read-only implementation of {@link Vector}
- * interface to minimize the effort required to implement it.
- * Subclasses may override some of the implemented methods if a more
- * specific or optimized implementation is desirable.
- */
-public abstract class AbstractReadOnlyVector extends AbstractVector {
- /** */
- public AbstractReadOnlyVector() {
- // No-op.
- }
-
- /**
- * @param sto Storage.
- */
- public AbstractReadOnlyVector(VectorStorage sto) {
- super(true, sto);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix cross(Vector vec) {
- return new FunctionMatrix(size(), vec.size(),
- (row, col) -> vec.get(col) * get(row));
- }
-
- /** {@inheritDoc} */
- @Override public Matrix toMatrix(boolean rowLike) {
- return new FunctionMatrix(rowLike ? 1 : size(), rowLike ? size() : 1,
- (row, col) -> rowLike ? get(col) : get(row));
- }
-
- /** {@inheritDoc} */
- @Override public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal) {
- return new FunctionMatrix(rowLike ? 1 : size() + 1, rowLike ? size() + 1 : 1, (row, col) -> {
- if (row == 0 && col == 0)
- return zeroVal;
-
- return rowLike ? get(col - 1) : get(row - 1);
- });
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- return this; // This exploits read-only feature of this type vector.
- }
-
- /** {@inheritDoc} */
- @Override public Vector logNormalize() {
- return logNormalize(2.0, Math.sqrt(getLengthSquared()));
- }
-
- /** {@inheritDoc} */
- @Override public Vector logNormalize(double power) {
- return logNormalize(power, kNorm(power));
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteDoubleFunction<Double> fun) {
- return new FunctionVector(size(), (i) -> fun.apply(get(i)));
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun) {
- checkCardinality(vec);
-
- return new FunctionVector(size(), (i) -> fun.apply(get(i), vec.get(i)));
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
- return new FunctionVector(size(), (i) -> fun.apply(get(i), y));
- }
-
- /** {@inheritDoc} */
- @Override public Vector divide(double x) {
- if (x == 1.0)
- return this;
-
- return new FunctionVector(size(), (i) -> get(i) / x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- return x == 0 ? new ConstantVector(size(), 0) : new FunctionVector(size(), (i) -> get(i) * x);
- }
-
- /**
- * @param power Power.
- * @param normLen Normalized length.
- * @return logNormalized value.
- */
- private Vector logNormalize(double power, double normLen) {
- assert !(Double.isInfinite(power) || power <= 1.0);
-
- double denominator = normLen * Math.log(power);
-
- return new FunctionVector(size(), (idx) -> Math.log1p(get(idx)) / denominator);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java
deleted file mode 100644
index d84c0f3..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/AbstractVector.java
+++ /dev/null
@@ -1,903 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Spliterator;
-import java.util.function.Consumer;
-import java.util.function.IntToDoubleFunction;
-import org.apache.ignite.lang.IgniteUuid;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.CardinalityException;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.impls.matrix.MatrixView;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * This class provides a helper implementation of the {@link Vector}
- * interface to minimize the effort required to implement it.
- * Subclasses may override some of the implemented methods if a more
- * specific or optimized implementation is desirable.
- */
-public abstract class AbstractVector implements Vector {
- /** Vector storage implementation. */
- private VectorStorage sto;
-
- /** Meta attribute storage. */
- private Map<String, Object> meta = new HashMap<>();
-
- /** Vector's GUID. */
- private IgniteUuid guid = IgniteUuid.randomUuid();
-
- /** Cached value for length squared. */
- private double lenSq = 0.0;
-
- /** Maximum cached element. */
- private Element maxElm = null;
- /** Minimum cached element. */
- private Element minElm = null;
-
- /** Readonly flag (false by default). */
- private boolean readOnly = false;
-
- /** Read-only error message. */
- private static final String RO_MSG = "Vector is read-only.";
-
- /**
- *
- */
- private void ensureReadOnly() {
- if (readOnly)
- throw new UnsupportedOperationException(RO_MSG);
- }
-
- /**
- * @param sto Storage.
- */
- public AbstractVector(VectorStorage sto) {
- this(false, sto);
- }
-
- /**
- * @param readOnly Is read only.
- * @param sto Storage.
- */
- public AbstractVector(boolean readOnly, VectorStorage sto) {
- assert sto != null;
-
- this.readOnly = readOnly;
- this.sto = sto;
- }
-
- /**
- *
- */
- public AbstractVector() {
- // No-op.
- }
-
- /**
- * Set storage.
- *
- * @param sto Storage.
- */
- protected void setStorage(VectorStorage sto) {
- this.sto = sto;
- }
-
- /**
- * @param i Index.
- * @param v Value.
- */
- protected void storageSet(int i, double v) {
- ensureReadOnly();
-
- sto.set(i, v);
-
- // Reset cached values.
- lenSq = 0.0;
- maxElm = minElm = null;
- }
-
- /**
- * @param i Index.
- * @return Value.
- */
- protected double storageGet(int i) {
- return sto.get(i);
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return sto.size();
- }
-
- /**
- * Check index bounds.
- *
- * @param idx Index to check.
- */
- protected void checkIndex(int idx) {
- if (idx < 0 || idx >= sto.size())
- throw new IndexException(idx);
- }
-
- /** {@inheritDoc} */
- @Override public double get(int idx) {
- checkIndex(idx);
-
- return storageGet(idx);
- }
-
- /** {@inheritDoc} */
- @Override public double getX(int idx) {
- return storageGet(idx);
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return sto.isArrayBased();
- }
-
- /** {@inheritDoc} */
- @Override public Vector sort() {
- if (isArrayBased())
- Arrays.parallelSort(sto.data());
- else
- throw new UnsupportedOperationException();
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteDoubleFunction<Double> fun) {
- if (sto.isArrayBased()) {
- double[] data = sto.data();
-
- Arrays.setAll(data, (idx) -> fun.apply(data[idx]));
- }
- else {
- int len = size();
-
- for (int i = 0; i < len; i++)
- storageSet(i, fun.apply(storageGet(i)));
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun) {
- checkCardinality(vec);
-
- int len = size();
-
- for (int i = 0; i < len; i++)
- storageSet(i, fun.apply(storageGet(i), vec.get(i)));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
- int len = size();
-
- for (int i = 0; i < len; i++)
- storageSet(i, fun.apply(storageGet(i), y));
-
- return this;
- }
-
- /**
- * @param idx Index.
- * @return Value.
- */
- protected Element makeElement(int idx) {
- checkIndex(idx);
-
- return new Element() {
- /** {@inheritDoc} */
- @Override public double get() {
- return storageGet(idx);
- }
-
- /** {@inheritDoc} */
- @Override public int index() {
- return idx;
- }
-
- /** {@inheritDoc} */
- @Override public void set(double val) {
- storageSet(idx, val);
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public Element minElement() {
- if (minElm == null) {
- int minIdx = 0;
- int len = size();
-
- for (int i = 0; i < len; i++)
- if (storageGet(i) < storageGet(minIdx))
- minIdx = i;
-
- minElm = makeElement(minIdx);
- }
-
- return minElm;
- }
-
- /** {@inheritDoc} */
- @Override public Element maxElement() {
- if (maxElm == null) {
- int maxIdx = 0;
- int len = size();
-
- for (int i = 0; i < len; i++)
- if (storageGet(i) > storageGet(maxIdx))
- maxIdx = i;
-
- maxElm = makeElement(maxIdx);
- }
-
- return maxElm;
- }
-
- /** {@inheritDoc} */
- @Override public double minValue() {
- return minElement().get();
- }
-
- /** {@inheritDoc} */
- @Override public double maxValue() {
- return maxElement().get();
- }
-
- /** {@inheritDoc} */
- @Override public Vector set(int idx, double val) {
- checkIndex(idx);
-
- storageSet(idx, val);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector setX(int idx, double val) {
- storageSet(idx, val);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector increment(int idx, double val) {
- checkIndex(idx);
-
- storageSet(idx, storageGet(idx) + val);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector incrementX(int idx, double val) {
- storageSet(idx, storageGet(idx) + val);
-
- return this;
- }
-
- /**
- * Tests if given value is considered a zero value.
- *
- * @param val Value to check.
- */
- protected boolean isZero(double val) {
- return val == 0.0;
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- double sum = 0;
- int len = size();
-
- for (int i = 0; i < len; i++)
- sum += storageGet(i);
-
- return sum;
- }
-
- /** {@inheritDoc} */
- @Override public IgniteUuid guid() {
- return guid;
- }
-
- /** {@inheritDoc} */
- @Override public Iterable<Element> all() {
- return new Iterable<Element>() {
- private int idx = 0;
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Element> iterator() {
- return new Iterator<Element>() {
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return size() > 0 && idx < size();
- }
-
- /** {@inheritDoc} */
- @Override public Element next() {
- if (hasNext())
- return getElement(idx++);
-
- throw new NoSuchElementException();
- }
- };
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public int nonZeroElements() {
- int cnt = 0;
-
- for (Element ignored : nonZeroes())
- cnt++;
-
- return cnt;
- }
-
- /** {@inheritDoc} */
- @Override public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun,
- T zeroVal) {
- T res = zeroVal;
- int len = size();
-
- for (int i = 0; i < len; i++)
- res = foldFun.apply(res, mapFun.apply(storageGet(i)));
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public <T> T foldMap(Vector vec, IgniteBiFunction<T, Double, T> foldFun,
- IgniteBiFunction<Double, Double, Double> combFun, T zeroVal) {
- checkCardinality(vec);
-
- T res = zeroVal;
- int len = size();
-
- for (int i = 0; i < len; i++)
- res = foldFun.apply(res, combFun.apply(storageGet(i), vec.getX(i)));
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Iterable<Element> nonZeroes() {
- return new Iterable<Element>() {
- private int idx = 0;
- private int idxNext = -1;
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Element> iterator() {
- return new Iterator<Element>() {
- @Override public boolean hasNext() {
- findNext();
-
- return !over();
- }
-
- @Override public Element next() {
- if (hasNext()) {
- idx = idxNext;
-
- return getElement(idxNext);
- }
-
- throw new NoSuchElementException();
- }
-
- private void findNext() {
- if (over())
- return;
-
- if (idxNextInitialized() && idx != idxNext)
- return;
-
- if (idxNextInitialized())
- idx = idxNext + 1;
-
- while (idx < size() && isZero(get(idx)))
- idx++;
-
- idxNext = idx++;
- }
-
- private boolean over() {
- return idxNext >= size();
- }
-
- private boolean idxNextInitialized() {
- return idxNext != -1;
- }
- };
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public Map<String, Object> getMetaStorage() {
- return meta;
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(double val) {
- if (sto.isArrayBased()) {
- ensureReadOnly();
-
- Arrays.fill(sto.data(), val);
- }
- else {
- int len = size();
-
- for (int i = 0; i < len; i++)
- storageSet(i, val);
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(double[] vals) {
- checkCardinality(vals);
-
- if (sto.isArrayBased()) {
- ensureReadOnly();
-
- System.arraycopy(vals, 0, sto.data(), 0, vals.length);
-
- lenSq = 0.0;
- }
- else {
- int len = size();
-
- for (int i = 0; i < len; i++)
- storageSet(i, vals[i]);
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(Vector vec) {
- checkCardinality(vec);
-
- for (Vector.Element x : vec.all())
- storageSet(x.index(), x.get());
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(IntToDoubleFunction fun) {
- assert fun != null;
-
- if (sto.isArrayBased()) {
- ensureReadOnly();
-
- Arrays.setAll(sto.data(), fun);
- }
- else {
- int len = size();
-
- for (int i = 0; i < len; i++)
- storageSet(i, fun.applyAsDouble(i));
- }
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Spliterator<Double> allSpliterator() {
- return new Spliterator<Double>() {
- /** {@inheritDoc} */
- @Override public boolean tryAdvance(Consumer<? super Double> act) {
- int len = size();
-
- for (int i = 0; i < len; i++)
- act.accept(storageGet(i));
-
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public Spliterator<Double> trySplit() {
- return null; // No Splitting.
- }
-
- /** {@inheritDoc} */
- @Override public long estimateSize() {
- return size();
- }
-
- /** {@inheritDoc} */
- @Override public int characteristics() {
- return ORDERED | SIZED;
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public Spliterator<Double> nonZeroSpliterator() {
- return new Spliterator<Double>() {
- /** {@inheritDoc} */
- @Override public boolean tryAdvance(Consumer<? super Double> act) {
- int len = size();
-
- for (int i = 0; i < len; i++) {
- double val = storageGet(i);
-
- if (!isZero(val))
- act.accept(val);
- }
-
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public Spliterator<Double> trySplit() {
- return null; // No Splitting.
- }
-
- /** {@inheritDoc} */
- @Override public long estimateSize() {
- return nonZeroElements();
- }
-
- /** {@inheritDoc} */
- @Override public int characteristics() {
- return ORDERED | SIZED;
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public double dot(Vector vec) {
- checkCardinality(vec);
-
- double sum = 0.0;
- int len = size();
-
- for (int i = 0; i < len; i++)
- sum += storageGet(i) * vec.getX(i);
-
- return sum;
- }
-
- /** {@inheritDoc} */
- @Override public double getLengthSquared() {
- if (lenSq == 0.0)
- lenSq = dotSelf();
-
- return lenSq;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return sto.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return sto.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return sto.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return sto.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public VectorStorage getStorage() {
- return sto;
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewPart(int off, int len) {
- return new VectorView(this, off, len);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix cross(Vector vec) {
- Matrix res = likeMatrix(size(), vec.size());
-
- if (res == null)
- return null;
-
- for (Element e : nonZeroes()) {
- int row = e.index();
-
- res.assignRow(row, vec.times(getX(row)));
- }
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix toMatrix(boolean rowLike) {
- Matrix res = likeMatrix(rowLike ? 1 : size(), rowLike ? size() : 1);
-
- if (res == null)
- return null;
-
- if (rowLike)
- res.assignRow(0, this);
- else
- res.assignColumn(0, this);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal) {
- Matrix res = likeMatrix(rowLike ? 1 : size() + 1, rowLike ? size() + 1 : 1);
-
- if (res == null)
- return null;
-
- res.set(0, 0, zeroVal);
-
- if (rowLike)
- new MatrixView(res, 0, 1, 1, size()).assignRow(0, this);
- else
- new MatrixView(res, 1, 0, size(), 1).assignColumn(0, this);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public double getDistanceSquared(Vector vec) {
- checkCardinality(vec);
-
- double thisLenSq = getLengthSquared();
- double thatLenSq = vec.getLengthSquared();
- double dot = dot(vec);
- double distEst = thisLenSq + thatLenSq - 2 * dot;
-
- if (distEst > 1.0e-3 * (thisLenSq + thatLenSq))
- // The vectors are far enough from each other that the formula is accurate.
- return Math.max(distEst, 0);
- else
- return foldMap(vec, Functions.PLUS, Functions.MINUS_SQUARED, 0d);
- }
-
- /** */
- protected void checkCardinality(Vector vec) {
- if (vec.size() != size())
- throw new CardinalityException(size(), vec.size());
- }
-
- /** */
- protected void checkCardinality(double[] vec) {
- if (vec.length != size())
- throw new CardinalityException(size(), vec.length);
- }
-
- /** */
- protected void checkCardinality(int[] arr) {
- if (arr.length != size())
- throw new CardinalityException(size(), arr.length);
- }
-
- /** {@inheritDoc} */
- @Override public Vector minus(Vector vec) {
- checkCardinality(vec);
-
- Vector cp = copy();
-
- return cp.map(vec, Functions.MINUS);
- }
-
- /** {@inheritDoc} */
- @Override public Vector plus(double x) {
- Vector cp = copy();
-
- return x != 0.0 ? cp.map(Functions.plus(x)) : cp;
- }
-
- /** {@inheritDoc} */
- @Override public Vector divide(double x) {
- Vector cp = copy();
-
- if (x != 1.0)
- for (Element element : cp.all())
- element.set(element.get() / x);
-
- return cp;
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- if (x == 0.0)
- return like(size());
- else
- return copy().map(Functions.mult(x));
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(Vector vec) {
- checkCardinality(vec);
-
- return copy().map(vec, Functions.MULT);
- }
-
- /** {@inheritDoc} */
- @Override public Vector plus(Vector vec) {
- checkCardinality(vec);
-
- Vector cp = copy();
-
- return cp.map(vec, Functions.PLUS);
- }
-
- /** {@inheritDoc} */
- @Override public Vector logNormalize() {
- return logNormalize(2.0, Math.sqrt(getLengthSquared()));
- }
-
- /** {@inheritDoc} */
- @Override public Vector logNormalize(double power) {
- return logNormalize(power, kNorm(power));
- }
-
- /**
- * @param power Power.
- * @param normLen Normalized length.
- * @return logNormalized value.
- */
- private Vector logNormalize(double power, double normLen) {
- assert !(Double.isInfinite(power) || power <= 1.0);
-
- double denominator = normLen * Math.log(power);
-
- Vector cp = copy();
-
- for (Element element : cp.all())
- element.set(Math.log1p(element.get()) / denominator);
-
- return cp;
- }
-
- /** {@inheritDoc} */
- @Override public double kNorm(double power) {
- assert power >= 0.0;
-
- // Special cases.
- if (Double.isInfinite(power))
- return foldMap(Math::max, Math::abs, 0d);
- else if (power == 2.0)
- return Math.sqrt(getLengthSquared());
- else if (power == 1.0)
- return foldMap(Functions.PLUS, Math::abs, 0d);
- else if (power == 0.0)
- return nonZeroElements();
- else
- // Default case.
- return Math.pow(foldMap(Functions.PLUS, Functions.pow(power), 0d), 1.0 / power);
- }
-
- /** {@inheritDoc} */
- @Override public Vector normalize() {
- return divide(Math.sqrt(getLengthSquared()));
- }
-
- /** {@inheritDoc} */
- @Override public Vector normalize(double power) {
- return divide(kNorm(power));
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- return like(size()).assign(this);
- }
-
- /**
- * @return Result of dot with self.
- */
- protected double dotSelf() {
- double sum = 0.0;
- int len = size();
-
- for (int i = 0; i < len; i++) {
- double v = storageGet(i);
-
- sum += v * v;
- }
-
- return sum;
- }
-
- /** {@inheritDoc} */
- @Override public Element getElement(int idx) {
- return makeElement(idx);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(sto);
- out.writeObject(meta);
- out.writeObject(guid);
- out.writeBoolean(readOnly);
- }
-
- /** {@inheritDoc} */
- @SuppressWarnings("unchecked")
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- sto = (VectorStorage)in.readObject();
- meta = (Map<String, Object>)in.readObject();
- guid = (IgniteUuid)in.readObject();
- readOnly = in.readBoolean();
- }
-
- /** {@inheritDoc} */
- @Override public void destroy() {
- sto.destroy();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
- res += res * 37 + guid.hashCode();
- res += sto == null ? 0 : res * 37 + sto.hashCode();
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- AbstractVector that = (AbstractVector)obj;
-
- return (sto != null ? sto.equals(that.sto) : that.sto == null);
- }
-}
[16/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java
deleted file mode 100644
index c0c2af7..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/DiagonalMatrixTest.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.ExternalizeTest;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/**
- * Tests for {@link DiagonalMatrix}.
- */
-public class DiagonalMatrixTest extends ExternalizeTest<DiagonalMatrix> {
- /** */
- public static final String UNEXPECTED_VALUE = "Unexpected value";
-
- /** */
- private DiagonalMatrix testMatrix;
-
- /** */
- @Before
- public void setup() {
- DenseLocalOnHeapMatrix parent = new DenseLocalOnHeapMatrix(MathTestConstants.STORAGE_SIZE, MathTestConstants.STORAGE_SIZE);
- fillMatrix(parent);
- testMatrix = new DiagonalMatrix(parent);
- }
-
- /** {@inheritDoc} */
- @Override public void externalizeTest() {
- externalizeTest(testMatrix);
- }
-
- /** */
- @Test
- public void testSetGetBasic() {
- double testVal = 42;
- for (int i = 0; i < MathTestConstants.STORAGE_SIZE; i++) {
- testMatrix.set(i, i, testVal);
-
- assertEquals(UNEXPECTED_VALUE + " at (" + i + "," + i + ")", testMatrix.get(i, i), testVal, 0d);
- }
-
- //noinspection EqualsWithItself
- assertTrue("Matrix is expected to be equal to self.", testMatrix.equals(testMatrix));
- //noinspection ObjectEqualsNull
- assertFalse("Matrix is expected to be not equal to null.", testMatrix.equals(null));
- }
-
- /** */
- @Test
- public void testSetGet() {
- verifyDiagonal(testMatrix);
-
- final int size = MathTestConstants.STORAGE_SIZE;
-
- for (Matrix m : new Matrix[] {
- new DenseLocalOnHeapMatrix(size + 1, size),
- new DenseLocalOnHeapMatrix(size, size + 1)}) {
- fillMatrix(m);
-
- verifyDiagonal(new DiagonalMatrix(m));
- }
-
- final double[] data = new double[size];
-
- for (int i = 0; i < size; i++)
- data[i] = 1 + i;
-
- final Matrix m = new DiagonalMatrix(new DenseLocalOnHeapVector(data));
-
- assertEquals("Rows in matrix constructed from vector", size, m.rowSize());
- assertEquals("Cols in matrix constructed from vector", size, m.columnSize());
-
- for (int i = 0; i < size; i++)
- assertEquals(UNEXPECTED_VALUE + " at vector index " + i, data[i], m.get(i, i), 0d);
-
- verifyDiagonal(m);
-
- final Matrix m1 = new DiagonalMatrix(data);
-
- assertEquals("Rows in matrix constructed from array", size, m1.rowSize());
- assertEquals("Cols in matrix constructed from array", size, m1.columnSize());
-
- for (int i = 0; i < size; i++)
- assertEquals(UNEXPECTED_VALUE + " at array index " + i, data[i], m1.get(i, i), 0d);
-
- verifyDiagonal(m1);
- }
-
- /** */
- @Test
- public void testConstant() {
- final int size = MathTestConstants.STORAGE_SIZE;
-
- for (double val : new double[] {-1.0, 0.0, 1.0}) {
- Matrix m = new DiagonalMatrix(size, val);
-
- assertEquals("Rows in matrix", size, m.rowSize());
- assertEquals("Cols in matrix", size, m.columnSize());
-
- for (int i = 0; i < size; i++)
- assertEquals(UNEXPECTED_VALUE + " at index " + i, val, m.get(i, i), 0d);
-
- verifyDiagonal(m, true);
- }
- }
-
- /** */
- @Test
- public void testAttributes() {
- assertTrue(UNEXPECTED_VALUE, testMatrix.rowSize() == MathTestConstants.STORAGE_SIZE);
- assertTrue(UNEXPECTED_VALUE, testMatrix.columnSize() == MathTestConstants.STORAGE_SIZE);
-
- assertFalse(UNEXPECTED_VALUE, testMatrix.isArrayBased());
- assertTrue(UNEXPECTED_VALUE, testMatrix.isDense());
- assertFalse(UNEXPECTED_VALUE, testMatrix.isDistributed());
-
- assertEquals(UNEXPECTED_VALUE, testMatrix.isRandomAccess(), !testMatrix.isSequentialAccess());
- assertTrue(UNEXPECTED_VALUE, testMatrix.isRandomAccess());
- }
-
- /** */
- @Test
- public void testNullParams() {
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DiagonalMatrix((Matrix)null), "Null Matrix parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DiagonalMatrix((Vector)null), "Null Vector parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new DiagonalMatrix((double[])null), "Null double[] parameter");
- }
-
- /** */
- private void verifyDiagonal(Matrix m, boolean readonly) {
- final int rows = m.rowSize(), cols = m.columnSize();
-
- final String sizeDetails = "rows" + "X" + "cols " + rows + "X" + cols;
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++) {
- final String details = " at (" + i + "," + j + "), " + sizeDetails;
-
- final boolean diagonal = i == j;
-
- final double old = m.get(i, j);
-
- if (!diagonal)
- assertEquals(UNEXPECTED_VALUE + details, 0, old, 0d);
-
- final double exp = diagonal && !readonly ? old + 1 : old;
-
- boolean expECaught = false;
-
- try {
- m.set(i, j, exp);
- }
- catch (UnsupportedOperationException uoe) {
- if (diagonal && !readonly)
- throw uoe;
-
- expECaught = true;
- }
-
- if ((!diagonal || readonly) && !expECaught)
- fail("Expected exception was not caught " + details);
-
- assertEquals(UNEXPECTED_VALUE + details, exp, m.get(i, j), 0d);
- }
- }
-
- /** */
- private void verifyDiagonal(Matrix m) {
- verifyDiagonal(m, false);
- }
-
- /** */
- private void fillMatrix(Matrix m) {
- final int rows = m.rowSize(), cols = m.columnSize();
-
- boolean negative = false;
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- m.set(i, j, (negative = !negative) ? -(i * cols + j + 1) : i * cols + j + 1);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java
deleted file mode 100644
index a5ac84a..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/FunctionMatrixConstructorTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class FunctionMatrixConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(0, 1, (i, j) -> 0.0),
- "Invalid row parameter.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 0, (i, j) -> 0.0),
- "Invalid col parameter.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 1, null),
- "Invalid func parameter.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(0, 1, (i, j) -> 0.0, null),
- "Invalid row parameter, with setter func.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 0, (i, j) -> 0.0, null),
- "Invalid col parameter, with setter func.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new FunctionMatrix(1, 1, null, null),
- "Invalid func parameter, with setter func.");
- }
-
- /** */
- @Test
- public void basicTest() {
- for (int rows : new int[] {1, 2, 3})
- for (int cols : new int[] {1, 2, 3})
- basicTest(rows, cols);
-
- Matrix m = new FunctionMatrix(1, 1, (i, j) -> 1d);
- //noinspection EqualsWithItself
- assertTrue("Matrix is expected to be equal to self.", m.equals(m));
- //noinspection ObjectEqualsNull
- assertFalse("Matrix is expected to be not equal to null.", m.equals(null));
- }
-
- /** */
- private void basicTest(int rows, int cols) {
- double[][] data = new double[rows][cols];
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++)
- data[row][col] = row * cols + row;
-
- Matrix mReadOnly = new FunctionMatrix(rows, cols, (i, j) -> data[i][j]);
-
- assertEquals("Rows in matrix.", rows, mReadOnly.rowSize());
- assertEquals("Cols in matrix.", cols, mReadOnly.columnSize());
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++) {
- assertEquals("Unexpected value at " + row + "x" + col, data[row][col], mReadOnly.get(row, col), 0d);
-
- boolean expECaught = false;
-
- try {
- mReadOnly.set(row, col, 0.0);
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expected exception wasn't thrown at " + row + "x" + col, expECaught);
- }
-
- Matrix m = new FunctionMatrix(rows, cols, (i, j) -> data[i][j], (i, j, val) -> data[i][j] = val);
-
- assertEquals("Rows in matrix, with setter function.", rows, m.rowSize());
- assertEquals("Cols in matrix, with setter function.", cols, m.columnSize());
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++) {
- assertEquals("Unexpected value at " + row + "x" + col, data[row][col], m.get(row, col), 0d);
-
- m.set(row, col, -data[row][col]);
- }
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++)
- assertEquals("Unexpected value set at " + row + "x" + col, -(row * cols + row), m.get(row, col), 0d);
-
- assertTrue("Incorrect copy for empty matrix.", m.copy().equals(m));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java
deleted file mode 100644
index c9fb390..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixAttributeTest.java
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * 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.matrix;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.Function;
-import org.apache.ignite.math.Matrix;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/**
- * Attribute tests for matrices.
- *
- * TODO: WIP
- */
-public class MatrixAttributeTest {
- /** */
- private final List<MatrixAttributeTest.AttrCfg> attrCfgs = Arrays.asList(
- new AttrCfg("isDense", Matrix::isDense,
- DenseLocalOnHeapMatrix.class, DenseLocalOffHeapMatrix.class, RandomMatrix.class, DiagonalMatrix.class),
- new AttrCfg("isArrayBased", Matrix::isArrayBased, DenseLocalOnHeapMatrix.class),
- new AttrCfg("isDistributed", Matrix::isDistributed),
- new AttrCfg("isRandomAccess", Matrix::isRandomAccess, DenseLocalOnHeapMatrix.class, DenseLocalOffHeapMatrix.class, RandomMatrix.class, DiagonalMatrix.class, SparseLocalOnHeapMatrix.class),
- new AttrCfg("isSequentialAccess", Matrix::isSequentialAccess, DiagonalMatrix.class)
- );
-
- /** */
- private final List<MatrixAttributeTest.Specification> specFixture = Arrays.asList(
- new Specification(new DenseLocalOnHeapMatrix(1, 1)),
- new Specification(new DenseLocalOffHeapMatrix(1, 1)),
- new Specification(new RandomMatrix(1, 1)),
- new Specification(new DiagonalMatrix(new double[] {1.0})),
- new Specification(new FunctionMatrix(1, 1, (x, y) -> 1.0)),
- new Specification(new SparseLocalOnHeapMatrix(1, 1))
- );
-
- /** */
- @Test
- public void isDenseTest() {
- assertAttribute("isDense");
- }
-
- /** */
- @Test
- public void isArrayBasedTest() {
- assertAttribute("isArrayBased");
- }
-
- /** */
- @Test
- public void isSequentialAccessTest() {
- assertAttribute("isSequentialAccess");
- }
-
- /** */
- @Test
- public void isRandomAccessTest() {
- assertAttribute("isRandomAccess");
- }
-
- /** */
- @Test
- public void isDistributedTest() {
- assertAttribute("isDistributed");
- }
-
- /** */
- private void assertAttribute(String name) {
- final MatrixAttributeTest.AttrCfg attr = attrCfg(name);
-
- for (MatrixAttributeTest.Specification spec : specFixture)
- spec.verify(attr);
- }
-
- /** */
- private MatrixAttributeTest.AttrCfg attrCfg(String name) {
- for (MatrixAttributeTest.AttrCfg attr : attrCfgs)
- if (attr.name.equals(name))
- return attr;
-
- throw new IllegalArgumentException("Undefined attribute " + name);
- }
-
- /** See http://en.wikipedia.org/wiki/Specification_pattern */
- private static class Specification {
- /** */
- private final Matrix m;
- /** */
- private final Class<? extends Matrix> underlyingType;
- /** */
- private final List<String> attrsFromUnderlying;
- /** */
- final String desc;
-
- /** */
- Specification(Matrix m, Class<? extends Matrix> underlyingType, String... attrsFromUnderlying) {
- this.m = m;
- this.underlyingType = underlyingType;
- this.attrsFromUnderlying = Arrays.asList(attrsFromUnderlying);
- final Class<? extends Matrix> clazz = m.getClass();
- desc = clazz.getSimpleName() + (clazz.equals(underlyingType)
- ? "" : " (underlying type " + underlyingType.getSimpleName() + ")");
- }
-
- /** */
- Specification(Matrix m) {
- this(m, m.getClass());
- }
-
- /** */
- void verify(MatrixAttributeTest.AttrCfg attr) {
- final boolean obtained = attr.obtain.apply(m);
-
- final Class<? extends Matrix> typeToCheck
- = attrsFromUnderlying.contains(attr.name) ? underlyingType : m.getClass();
-
- final boolean exp = attr.trueInTypes.contains(typeToCheck);
-
- assertEquals("Unexpected " + attr.name + " value for " + desc, exp, obtained);
- }
- }
-
- /** */
- private static class AttrCfg {
- /** */
- final String name;
- /** */
- final Function<Matrix, Boolean> obtain;
- /** */
- final List<Class> trueInTypes;
-
- /** */
- AttrCfg(String name, Function<Matrix, Boolean> obtain, Class... trueInTypes) {
- this.name = name;
- this.obtain = obtain;
- this.trueInTypes = Arrays.asList(trueInTypes);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java
deleted file mode 100644
index 88aa4fe..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationFixtures.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
- * 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.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.impls.storage.matrix.FunctionMatrixStorage;
-import org.jetbrains.annotations.NotNull;
-
-/** */
-class MatrixImplementationFixtures {
- /** */
- private static final List<Supplier<Iterable<Matrix>>> suppliers = Arrays.asList(
- (Supplier<Iterable<Matrix>>)DenseLocalOnHeapMatrixFixture::new,
- (Supplier<Iterable<Matrix>>)DenseLocalOffHeapMatrixFixture::new,
- (Supplier<Iterable<Matrix>>)RandomMatrixFixture::new,
- (Supplier<Iterable<Matrix>>)SparseLocalOnHeapMatrixFixture::new,
- (Supplier<Iterable<Matrix>>)PivotedMatrixViewFixture::new,
- (Supplier<Iterable<Matrix>>)MatrixViewFixture::new,
- (Supplier<Iterable<Matrix>>)FunctionMatrixFixture::new,
- (Supplier<Iterable<Matrix>>)DiagonalMatrixFixture::new,
- (Supplier<Iterable<Matrix>>)TransposedMatrixViewFixture::new
- );
-
- /** */
- void consumeSampleMatrix(BiConsumer<Matrix, String> consumer) {
- for (Supplier<Iterable<Matrix>> fixtureSupplier : suppliers) {
- final Iterable<Matrix> fixture = fixtureSupplier.get();
-
- for (Matrix matrix : fixture) {
- consumer.accept(matrix, fixture.toString());
-
- matrix.destroy();
- }
- }
- }
-
- /** */
- private static class DenseLocalOnHeapMatrixFixture extends MatrixSizeIterator {
- /** */
- DenseLocalOnHeapMatrixFixture() {
- super(DenseLocalOnHeapMatrix::new, "DenseLocalOnHeapMatrix");
- }
- }
-
- /** */
- private static class DenseLocalOffHeapMatrixFixture extends MatrixSizeIterator {
- /** */
- DenseLocalOffHeapMatrixFixture() {
- super(DenseLocalOffHeapMatrix::new, "DenseLocalOffHeapMatrix");
- }
- }
-
- /** */
- private static class RandomMatrixFixture extends MatrixSizeIterator {
- /** */
- RandomMatrixFixture() {
- super(RandomMatrix::new, "RandomMatrix");
- }
- }
-
- /** */
- private static class SparseLocalOnHeapMatrixFixture extends MatrixSizeIterator {
- /** */
- SparseLocalOnHeapMatrixFixture() {
- super(SparseLocalOnHeapMatrix::new, "SparseLocalOnHeapMatrix");
- }
- }
-
- /** */
- private static class PivotedMatrixViewFixture extends WrapperMatrixIterator {
- /** */
- PivotedMatrixViewFixture() {
- super(PivotedMatrixView::new, "PivotedMatrixView over DenseLocalOnHeapMatrix");
- }
- }
-
- /** */
- private static class MatrixViewFixture extends WrapperMatrixIterator {
- /** */
- MatrixViewFixture() {
- super((matrix) -> new MatrixView(matrix, 0, 0, matrix.rowSize(), matrix.columnSize()),
- "MatrixView over DenseLocalOnHeapMatrix");
- }
- }
-
- /** */
- private static class FunctionMatrixFixture extends WrapperMatrixIterator {
- /** */
- FunctionMatrixFixture() {
- super(FunctionMatrixForTest::new, "FunctionMatrix wrapping DenseLocalOnHeapMatrix");
- }
- }
-
- /** */
- private static class DiagonalMatrixFixture extends DiagonalIterator {
- /** */
- DiagonalMatrixFixture() {
- super(DenseLocalOnHeapMatrix::new, "DiagonalMatrix over DenseLocalOnHeapMatrix");
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Matrix> iterator() {
- return new Iterator<Matrix>() {
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return hasNextSize(getSizeIdx());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix next() {
- assert getSize(getSizeIdx()) == 1 : "Only size 1 allowed for diagonal matrix fixture.";
-
- Matrix matrix = getConstructor().apply(getSize(getSizeIdx()), getSize(getSizeIdx()));
-
- nextIdx();
-
- return new DiagonalMatrix(matrix);
- }
- };
- }
- }
-
- /** */
- private static class TransposedMatrixViewFixture extends WrapperMatrixIterator {
- /** */
- TransposedMatrixViewFixture() {
- super(TransposedMatrixView::new, "TransposedMatrixView over DenseLocalOnHeapMatrix");
- }
- }
-
- /** */
- private static abstract class DiagonalIterator implements Iterable<Matrix> {
- /** */
- private final Integer[] sizes = new Integer[] {1, null};
- /** */
- private int sizeIdx = 0;
-
- /** */
- private BiFunction<Integer, Integer, ? extends Matrix> constructor;
- /** */
- private String desc;
-
- /** */
- DiagonalIterator(BiFunction<Integer, Integer, ? extends Matrix> constructor, String desc) {
- this.constructor = constructor;
- this.desc = desc;
- }
-
- /** */
- public BiFunction<Integer, Integer, ? extends Matrix> getConstructor() {
- return constructor;
- }
-
- /** */
- int getSizeIdx() {
- return sizeIdx;
- }
-
- /** */
- @Override public String toString() {
- return desc + "{rows=" + sizes[sizeIdx] + ", cols=" + sizes[sizeIdx] + "}";
- }
-
- /** */
- boolean hasNextSize(int idx) {
- return sizes[idx] != null;
- }
-
- /** */
- Integer getSize(int idx) {
- return sizes[idx];
- }
-
- /** */
- void nextIdx() {
- sizeIdx++;
- }
- }
-
- /** */
- private static class WrapperMatrixIterator extends MatrixSizeIterator {
- /** */
- private final Function<Matrix, Matrix> wrapperCtor;
-
- /** */
- WrapperMatrixIterator(Function<Matrix, Matrix> wrapperCtor, String desc) {
- super(DenseLocalOnHeapMatrix::new, desc);
-
- this.wrapperCtor = wrapperCtor;
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Matrix> iterator() {
- return new Iterator<Matrix>() {
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return hasNextCol(getSizeIdx()) && hasNextRow(getSizeIdx());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix next() {
- Matrix matrix = getConstructor().apply(getRow(getSizeIdx()), getCol(getSizeIdx()));
-
- nextIdx();
-
- return wrapperCtor.apply(matrix);
- }
- };
- }
- }
-
- /** */
- private static class MatrixSizeIterator implements Iterable<Matrix> {
- /** */
- private final Integer[] rows = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 1024, null};
- /** */
- private final Integer[] cols = new Integer[] {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 1024, 512, null};
- /** */
- private int sizeIdx = 0;
-
- /** */
- private BiFunction<Integer, Integer, ? extends Matrix> constructor;
- /** */
- private String desc;
-
- /** */
- MatrixSizeIterator(BiFunction<Integer, Integer, ? extends Matrix> constructor, String desc) {
- this.constructor = constructor;
- this.desc = desc;
- }
-
- /** */
- public BiFunction<Integer, Integer, ? extends Matrix> getConstructor() {
- return constructor;
- }
-
- /** */
- int getSizeIdx() {
- return sizeIdx;
- }
-
- /** */
- @Override public String toString() {
- return desc + "{rows=" + rows[sizeIdx] + ", cols=" + cols[sizeIdx] + "}";
- }
-
- /** */
- boolean hasNextRow(int idx) {
- return rows[idx] != null;
- }
-
- /** */
- boolean hasNextCol(int idx) {
- return cols[idx] != null;
- }
-
- /** */
- Integer getRow(int idx) {
- return rows[idx];
- }
-
- /** */
- int getCol(int idx) {
- return cols[idx];
- }
-
- /** {@inheritDoc} */
- @NotNull
- @Override public Iterator<Matrix> iterator() {
- return new Iterator<Matrix>() {
- /** {@inheritDoc} */
- @Override public boolean hasNext() {
- return hasNextCol(sizeIdx) && hasNextRow(sizeIdx);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix next() {
- Matrix matrix = constructor.apply(rows[sizeIdx], cols[sizeIdx]);
-
- nextIdx();
-
- return matrix;
- }
- };
- }
-
- /** */
- void nextIdx() {
- sizeIdx++;
- }
- }
-
- /** Subclass tweaked for serialization */
- private static class FunctionMatrixForTest extends FunctionMatrix {
- /** */
- Matrix underlying;
-
- /** */
- public FunctionMatrixForTest() {
- // No-op.
- }
-
- /** */
- FunctionMatrixForTest(Matrix underlying) {
- super(underlying.rowSize(), underlying.columnSize(), underlying::get, underlying::set);
-
- this.underlying = underlying;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- return new FunctionMatrixForTest(underlying);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeObject(underlying);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- underlying = (Matrix)in.readObject();
-
- setStorage(new FunctionMatrixStorage(underlying.rowSize(), underlying.columnSize(),
- underlying::get, underlying::set));
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + underlying.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- FunctionMatrixForTest that = (FunctionMatrixForTest)o;
-
- return underlying != null ? underlying.equals(that.underlying) : that.underlying == null;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java
deleted file mode 100644
index 28abab7..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixImplementationsTest.java
+++ /dev/null
@@ -1,1113 +0,0 @@
-/*
- * 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.matrix;
-
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.BiConsumer;
-import java.util.function.Supplier;
-import org.apache.ignite.math.ExternalizeTest;
-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.ColumnIndexException;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.exceptions.RowIndexException;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-import org.apache.ignite.math.impls.vector.RandomVector;
-import org.apache.ignite.math.impls.vector.SparseLocalVector;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/**
- * Tests for {@link Matrix} implementations.
- */
-public class MatrixImplementationsTest extends ExternalizeTest<Matrix> {
- /** */
- private static final double DEFAULT_DELTA = 0.000000001d;
-
- /** */
- private void consumeSampleMatrix(BiConsumer<Matrix, String> consumer) {
- new MatrixImplementationFixtures().consumeSampleMatrix(consumer);
- }
-
- /** */
- @Test
- public void externalizeTest() {
- consumeSampleMatrix((m, desc) -> externalizeTest(m));
- }
-
- /** */
- @Test
- public void testLike() {
- consumeSampleMatrix((m, desc) -> {
- Class<? extends Matrix> cls = likeMatrixType(m);
-
- if (cls != null) {
- Matrix like = m.like(m.rowSize(), m.columnSize());
-
- assertEquals("Wrong \"like\" matrix for " + desc + "; Unexpected rows.", like.rowSize(), m.rowSize());
- assertEquals("Wrong \"like\" matrix for " + desc + "; Unexpected columns.", like.columnSize(), m.columnSize());
-
- assertEquals("Wrong \"like\" matrix for " + desc
- + "; Unexpected class: " + like.getClass().toString(),
- cls,
- like.getClass());
-
- return;
- }
-
- boolean expECaught = false;
-
- try {
- m.like(1, 1);
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expected exception was not caught for " + desc, expECaught);
- });
- }
-
- /** */
- @Test
- public void testCopy() {
- consumeSampleMatrix((m, desc) -> {
- Matrix cp = m.copy();
- assertTrue("Incorrect copy for empty matrix " + desc, cp.equals(m));
-
- if (!readOnly(m))
- fillMatrix(m);
-
- cp = m.copy();
-
- assertTrue("Incorrect copy for matrix " + desc, cp.equals(m));
- });
- }
-
- /** */
- @Test
- public void testHaveLikeVector() throws InstantiationException, IllegalAccessException {
- for (Class<? extends Matrix> key : likeVectorTypesMap().keySet()) {
- Class<? extends Vector> val = likeVectorTypesMap().get(key);
-
- if (val == null && !ignore(key))
- System.out.println("Missing test for implementation of likeMatrix for " + key.getSimpleName());
- }
- }
-
- /** */
- @Test
- public void testLikeVector() {
- consumeSampleMatrix((m, desc) -> {
- if (likeVectorTypesMap().containsKey(m.getClass())) {
- Vector likeVector = m.likeVector(m.columnSize());
-
- assertNotNull(likeVector);
- assertEquals("Unexpected value for " + desc, likeVector.size(), m.columnSize());
-
- return;
- }
-
- boolean expECaught = false;
-
- try {
- m.likeVector(1);
- }
- catch (UnsupportedOperationException uoe) {
- expECaught = true;
- }
-
- assertTrue("Expected exception was not caught for " + desc, expECaught);
- });
- }
-
- /** */
- @Test
- public void testAssignSingleElement() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- final double assignVal = Math.random();
-
- m.assign(assignVal);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- assignVal, m.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testAssignArray() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- double[][] data = new double[m.rowSize()][m.columnSize()];
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- data[i][j] = Math.random();
-
- m.assign(data);
-
- for (int i = 0; i < m.rowSize(); i++) {
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- data[i][j], m.get(i, j), 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testAssignFunction() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- m.assign((i, j) -> (double)(i * m.columnSize() + j));
-
- for (int i = 0; i < m.rowSize(); i++) {
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- (double)(i * m.columnSize() + j), m.get(i, j), 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testPlus() {
- consumeSampleMatrix((m, desc) -> {
- if (readOnly(m))
- return;
-
- double[][] data = fillAndReturn(m);
-
- double plusVal = Math.random();
-
- Matrix plus = m.plus(plusVal);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- data[i][j] + plusVal, plus.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testPlusMatrix() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- double[][] data = fillAndReturn(m);
-
- Matrix plus = m.plus(m);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- data[i][j] * 2.0, plus.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testMinusMatrix() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- Matrix minus = m.minus(m);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- 0.0, minus.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testTimes() {
- consumeSampleMatrix((m, desc) -> {
- if (readOnly(m))
- return;
-
- double[][] data = fillAndReturn(m);
-
- double timeVal = Math.random();
- Matrix times = m.times(timeVal);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- data[i][j] * timeVal, times.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testTimesVector() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- double[][] data = fillAndReturn(m);
-
- double[] arr = fillArray(m.columnSize());
-
- Vector times = m.times(new DenseLocalOnHeapVector(arr));
-
- assertEquals("Unexpected vector size for " + desc, times.size(), m.rowSize());
-
- for (int i = 0; i < m.rowSize(); i++) {
- double exp = 0.0;
-
- for (int j = 0; j < m.columnSize(); j++)
- exp += arr[j] * data[i][j];
-
- assertEquals("Unexpected value for " + desc + " at " + i,
- times.get(i), exp, 0d);
- }
-
- testInvalidCardinality(() -> m.times(new DenseLocalOnHeapVector(m.columnSize() + 1)), desc);
- });
- }
-
- /** */
- @Test
- public void testTimesMatrix() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- double[][] data = fillAndReturn(m);
-
- double[] arr = fillArray(m.columnSize());
-
- Matrix mult = new DenseLocalOnHeapMatrix(m.columnSize(), 1);
-
- mult.setColumn(0, arr);
-
- Matrix times = m.times(mult);
-
- assertEquals("Unexpected rows for " + desc, times.rowSize(), m.rowSize());
-
- assertEquals("Unexpected cols for " + desc, times.columnSize(), 1);
-
- for (int i = 0; i < m.rowSize(); i++) {
- double exp = 0.0;
-
- for (int j = 0; j < m.columnSize(); j++)
- exp += arr[j] * data[i][j];
-
- assertEquals("Unexpected value for " + desc + " at " + i,
- exp, times.get(i, 0), 0d);
- }
-
- testInvalidCardinality(() -> m.times(new DenseLocalOnHeapMatrix(m.columnSize() + 1, 1)), desc);
- });
- }
-
- /** */
- @Test
- public void testDivide() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- double[][] data = fillAndReturn(m);
-
- double divVal = Math.random();
-
- Matrix divide = m.divide(divVal);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- data[i][j] / divVal, divide.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testTranspose() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- Matrix transpose = m.transpose();
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- m.get(i, j), transpose.get(j, i), 0d);
- });
- }
-
- /** */
- @Test
- public void testDeterminant() {
- consumeSampleMatrix((m, desc) -> {
- if (m.rowSize() != m.columnSize())
- return;
-
- if (ignore(m.getClass()))
- return;
-
- double[][] doubles = fillIntAndReturn(m);
-
- if (m.rowSize() == 1) {
- assertEquals("Unexpected value " + desc, m.determinant(), doubles[0][0], 0d);
-
- return;
- }
-
- if (m.rowSize() == 2) {
- double det = doubles[0][0] * doubles[1][1] - doubles[0][1] * doubles[1][0];
- assertEquals("Unexpected value " + desc, m.determinant(), det, 0d);
-
- return;
- }
-
- if (m.rowSize() > 512)
- return; // IMPL NOTE if row size >= 30000 it takes unacceptably long for normal test run.
-
- Matrix diagMtx = m.like(m.rowSize(), m.columnSize());
-
- diagMtx.assign(0);
- for (int i = 0; i < m.rowSize(); i++)
- diagMtx.set(i, i, m.get(i, i));
-
- double det = 1;
-
- for (int i = 0; i < diagMtx.rowSize(); i++)
- det *= diagMtx.get(i, i);
-
- try {
- assertEquals("Unexpected value " + desc, det, diagMtx.determinant(), DEFAULT_DELTA);
- }
- catch (Exception e) {
- System.out.println(desc);
- throw e;
- }
- });
- }
-
- /** */
- @Test
- public void testInverse() {
- consumeSampleMatrix((m, desc) -> {
- if (m.rowSize() != m.columnSize())
- return;
-
- if (ignore(m.getClass()))
- return;
-
- if (m.rowSize() > 256)
- return; // IMPL NOTE this is for quicker test run.
-
- fillNonSingularMatrix(m);
-
- assertTrue("Unexpected zero determinant " + desc, Math.abs(m.determinant()) > 0d);
-
- Matrix inverse = m.inverse();
-
- Matrix mult = m.times(inverse);
-
- final double delta = 0.001d;
-
- assertEquals("Unexpected determinant " + desc, 1d, mult.determinant(), delta);
-
- assertEquals("Unexpected top left value " + desc, 1d, mult.get(0, 0), delta);
-
- if (m.rowSize() == 1)
- return;
-
- assertEquals("Unexpected center value " + desc,
- 1d, mult.get(m.rowSize() / 2, m.rowSize() / 2), delta);
-
- assertEquals("Unexpected bottom right value " + desc,
- 1d, mult.get(m.rowSize() - 1, m.rowSize() - 1), delta);
-
- assertEquals("Unexpected top right value " + desc,
- 0d, mult.get(0, m.rowSize() - 1), delta);
-
- assertEquals("Unexpected bottom left value " + desc,
- 0d, mult.get(m.rowSize() - 1, 0), delta);
- });
- }
-
- /** */
- @Test
- public void testMap() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- m.map(x -> 10d);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- 10d, m.get(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testMapMatrix() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- double[][] doubles = fillAndReturn(m);
-
- testMapMatrixWrongCardinality(m, desc);
-
- Matrix cp = m.copy();
-
- m.map(cp, (m1, m2) -> m1 + m2);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- m.get(i, j), doubles[i][j] * 2, 0d);
- });
- }
-
- /** */
- @Test
- public void testViewRow() {
- consumeSampleMatrix((m, desc) -> {
- if (!readOnly(m))
- fillMatrix(m);
-
- for (int i = 0; i < m.rowSize(); i++) {
- Vector vector = m.viewRow(i);
- assert vector != null;
-
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- m.get(i, j), vector.get(j), 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testViewCol() {
- consumeSampleMatrix((m, desc) -> {
- if (!readOnly(m))
- fillMatrix(m);
-
- for (int i = 0; i < m.columnSize(); i++) {
- Vector vector = m.viewColumn(i);
- assert vector != null;
-
- for (int j = 0; j < m.rowSize(); j++)
- assertEquals("Unexpected value for " + desc + " at (" + i + "," + j + ")",
- m.get(j, i), vector.get(j), 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testFoldRow() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- Vector foldRows = m.foldRows(Vector::sum);
-
- for (int i = 0; i < m.rowSize(); i++) {
- Double locSum = 0d;
-
- for (int j = 0; j < m.columnSize(); j++)
- locSum += m.get(i, j);
-
- assertEquals("Unexpected value for " + desc + " at " + i,
- foldRows.get(i), locSum, 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testFoldCol() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- Vector foldCols = m.foldColumns(Vector::sum);
-
- for (int j = 0; j < m.columnSize(); j++) {
- Double locSum = 0d;
-
- for (int i = 0; i < m.rowSize(); i++)
- locSum += m.get(i, j);
-
- assertEquals("Unexpected value for " + desc + " at " + j,
- foldCols.get(j), locSum, 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testSum() {
- consumeSampleMatrix((m, desc) -> {
- double[][] data = fillAndReturn(m);
-
- double sum = m.sum();
-
- double rawSum = 0;
- for (double[] anArr : data)
- for (int j = 0; j < data[0].length; j++)
- rawSum += anArr[j];
-
- assertEquals("Unexpected value for " + desc,
- rawSum, sum, 0d);
- });
- }
-
- /** */
- @Test
- public void testMax() {
- consumeSampleMatrix((m, desc) -> {
- double[][] doubles = fillAndReturn(m);
- double max = Double.NEGATIVE_INFINITY;
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- max = max < doubles[i][j] ? doubles[i][j] : max;
-
- assertEquals("Unexpected value for " + desc, m.maxValue(), max, 0d);
- });
- }
-
- /** */
- @Test
- public void testMin() {
- consumeSampleMatrix((m, desc) -> {
- double[][] doubles = fillAndReturn(m);
- double min = Double.MAX_VALUE;
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- min = min > doubles[i][j] ? doubles[i][j] : min;
-
- assertEquals("Unexpected value for " + desc, m.minValue(), min, 0d);
- });
- }
-
- /** */
- @Test
- public void testGetElement() {
- consumeSampleMatrix((m, desc) -> {
- if (!(readOnly(m)))
- fillMatrix(m);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++) {
- final Matrix.Element e = m.getElement(i, j);
-
- final String details = desc + " at [" + i + "," + j + "]";
-
- assertEquals("Unexpected element row " + details, i, e.row());
- assertEquals("Unexpected element col " + details, j, e.column());
-
- final double val = m.get(i, j);
-
- assertEquals("Unexpected value for " + details, val, e.get(), 0d);
-
- boolean expECaught = false;
-
- final double newVal = val * 2.0;
-
- try {
- e.set(newVal);
- }
- catch (UnsupportedOperationException uoe) {
- if (!(readOnly(m)))
- throw uoe;
-
- expECaught = true;
- }
-
- if (readOnly(m)) {
- if (!expECaught)
- fail("Expected exception was not caught for " + details);
-
- continue;
- }
-
- assertEquals("Unexpected value set for " + details, newVal, m.get(i, j), 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testGetX() {
- consumeSampleMatrix((m, desc) -> {
- if (!(readOnly(m)))
- fillMatrix(m);
-
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- assertEquals("Unexpected value for " + desc + " at [" + i + "," + j + "]",
- m.get(i, j), m.getX(i, j), 0d);
- });
- }
-
- /** */
- @Test
- public void testGetMetaStorage() {
- consumeSampleMatrix((m, desc) -> assertNotNull("Null meta storage in " + desc, m.getMetaStorage()));
- }
-
- /** */
- @Test
- public void testGuid() {
- consumeSampleMatrix((m, desc) -> assertNotNull("Null guid in " + desc, m.guid()));
- }
-
- /** */
- @Test
- public void testSwapRows() {
- consumeSampleMatrix((m, desc) -> {
- if (readOnly(m))
- return;
-
- double[][] doubles = fillAndReturn(m);
-
- final int swap_i = m.rowSize() == 1 ? 0 : 1;
- final int swap_j = 0;
-
- Matrix swap = m.swapRows(swap_i, swap_j);
-
- for (int col = 0; col < m.columnSize(); col++) {
- assertEquals("Unexpected value for " + desc + " at col " + col + ", swap_i " + swap_i,
- swap.get(swap_i, col), doubles[swap_j][col], 0d);
-
- assertEquals("Unexpected value for " + desc + " at col " + col + ", swap_j " + swap_j,
- swap.get(swap_j, col), doubles[swap_i][col], 0d);
- }
-
- testInvalidRowIndex(() -> m.swapRows(-1, 0), desc + " negative first swap index");
- testInvalidRowIndex(() -> m.swapRows(0, -1), desc + " negative second swap index");
- testInvalidRowIndex(() -> m.swapRows(m.rowSize(), 0), desc + " too large first swap index");
- testInvalidRowIndex(() -> m.swapRows(0, m.rowSize()), desc + " too large second swap index");
- });
- }
-
- /** */
- @Test
- public void testSwapColumns() {
- consumeSampleMatrix((m, desc) -> {
- if (readOnly(m))
- return;
-
- double[][] doubles = fillAndReturn(m);
-
- final int swap_i = m.columnSize() == 1 ? 0 : 1;
- final int swap_j = 0;
-
- Matrix swap = m.swapColumns(swap_i, swap_j);
-
- for (int row = 0; row < m.rowSize(); row++) {
- assertEquals("Unexpected value for " + desc + " at row " + row + ", swap_i " + swap_i,
- swap.get(row, swap_i), doubles[row][swap_j], 0d);
-
- assertEquals("Unexpected value for " + desc + " at row " + row + ", swap_j " + swap_j,
- swap.get(row, swap_j), doubles[row][swap_i], 0d);
- }
-
- testInvalidColIndex(() -> m.swapColumns(-1, 0), desc + " negative first swap index");
- testInvalidColIndex(() -> m.swapColumns(0, -1), desc + " negative second swap index");
- testInvalidColIndex(() -> m.swapColumns(m.columnSize(), 0), desc + " too large first swap index");
- testInvalidColIndex(() -> m.swapColumns(0, m.columnSize()), desc + " too large second swap index");
- });
- }
-
- /** */
- @Test
- public void testSetRow() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- int rowIdx = m.rowSize() / 2;
-
- double[] newValues = fillArray(m.columnSize());
-
- m.setRow(rowIdx, newValues);
-
- for (int col = 0; col < m.columnSize(); col++)
- assertEquals("Unexpected value for " + desc + " at " + col,
- newValues[col], m.get(rowIdx, col), 0d);
-
- testInvalidCardinality(() -> m.setRow(rowIdx, new double[m.columnSize() + 1]), desc);
- });
- }
-
- /** */
- @Test
- public void testSetColumn() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- int colIdx = m.columnSize() / 2;
-
- double[] newValues = fillArray(m.rowSize());
-
- m.setColumn(colIdx, newValues);
-
- for (int row = 0; row < m.rowSize(); row++)
- assertEquals("Unexpected value for " + desc + " at " + row,
- newValues[row], m.get(row, colIdx), 0d);
-
- testInvalidCardinality(() -> m.setColumn(colIdx, new double[m.rowSize() + 1]), desc);
- });
- }
-
- /** */
- @Test
- public void testViewPart() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- int rowOff = m.rowSize() < 3 ? 0 : 1;
- int rows = m.rowSize() < 3 ? 1 : m.rowSize() - 2;
- int colOff = m.columnSize() < 3 ? 0 : 1;
- int cols = m.columnSize() < 3 ? 1 : m.columnSize() - 2;
-
- Matrix view1 = m.viewPart(rowOff, rows, colOff, cols);
- Matrix view2 = m.viewPart(new int[] {rowOff, colOff}, new int[] {rows, cols});
-
- String details = desc + " view [" + rowOff + ", " + rows + ", " + colOff + ", " + cols + "]";
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++) {
- assertEquals("Unexpected view1 value for " + details + " at (" + i + "," + j + ")",
- m.get(i + rowOff, j + colOff), view1.get(i, j), 0d);
-
- assertEquals("Unexpected view2 value for " + details + " at (" + i + "," + j + ")",
- m.get(i + rowOff, j + colOff), view2.get(i, j), 0d);
- }
- });
- }
-
- /** */
- @Test
- public void testDensity() {
- consumeSampleMatrix((m, desc) -> {
- if (!readOnly(m))
- fillMatrix(m);
-
- assertTrue("Unexpected density with threshold 0 for " + desc, m.density(0.0));
-
- assertFalse("Unexpected density with threshold 1 for " + desc, m.density(1.0));
- });
- }
-
- /** */
- @Test
- public void testMaxAbsRowSumNorm() {
- consumeSampleMatrix((m, desc) -> {
- if (!readOnly(m))
- fillMatrix(m);
-
- assertEquals("Unexpected value for " + desc,
- maxAbsRowSumNorm(m), m.maxAbsRowSumNorm(), 0d);
- });
- }
-
- /** */
- @Test
- public void testAssignRow() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- int rowIdx = m.rowSize() / 2;
-
- double[] newValues = fillArray(m.columnSize());
-
- m.assignRow(rowIdx, new DenseLocalOnHeapVector(newValues));
-
- for (int col = 0; col < m.columnSize(); col++)
- assertEquals("Unexpected value for " + desc + " at " + col,
- newValues[col], m.get(rowIdx, col), 0d);
-
- testInvalidCardinality(() -> m.assignRow(rowIdx, new DenseLocalOnHeapVector(m.columnSize() + 1)), desc);
- });
- }
-
- /** */
- @Test
- public void testAssignColumn() {
- consumeSampleMatrix((m, desc) -> {
- if (ignore(m.getClass()))
- return;
-
- fillMatrix(m);
-
- int colIdx = m.columnSize() / 2;
-
- double[] newValues = fillArray(m.rowSize());
-
- m.assignColumn(colIdx, new DenseLocalOnHeapVector(newValues));
-
- for (int row = 0; row < m.rowSize(); row++)
- assertEquals("Unexpected value for " + desc + " at " + row,
- newValues[row], m.get(row, colIdx), 0d);
- });
- }
-
- /** */
- private double[] fillArray(int len) {
- double[] newValues = new double[len];
-
- for (int i = 0; i < newValues.length; i++)
- newValues[i] = newValues.length - i;
- return newValues;
- }
-
- /** */
- private double maxAbsRowSumNorm(Matrix m) {
- double max = 0.0;
-
- for (int x = 0; x < m.rowSize(); x++) {
- double sum = 0;
-
- for (int y = 0; y < m.columnSize(); y++)
- sum += Math.abs(m.getX(x, y));
-
- if (sum > max)
- max = sum;
- }
-
- return max;
- }
-
- /** */
- private void testInvalidRowIndex(Supplier<Matrix> supplier, String desc) {
- try {
- supplier.get();
- }
- catch (RowIndexException | IndexException ie) {
- return;
- }
-
- fail("Expected exception was not caught for " + desc);
- }
-
- /** */
- private void testInvalidColIndex(Supplier<Matrix> supplier, String desc) {
- try {
- supplier.get();
- }
- catch (ColumnIndexException | IndexException ie) {
- return;
- }
-
- fail("Expected exception was not caught for " + desc);
- }
-
- /** */
- private void testMapMatrixWrongCardinality(Matrix m, String desc) {
- for (int rowDelta : new int[] {-1, 0, 1})
- for (int colDelta : new int[] {-1, 0, 1}) {
- if (rowDelta == 0 && colDelta == 0)
- continue;
-
- int rowNew = m.rowSize() + rowDelta;
- int colNew = m.columnSize() + colDelta;
-
- if (rowNew < 1 || colNew < 1)
- continue;
-
- testInvalidCardinality(() -> m.map(new DenseLocalOnHeapMatrix(rowNew, colNew), (m1, m2) -> m1 + m2),
- desc + " wrong cardinality when mapping to size " + rowNew + "x" + colNew);
- }
- }
-
- /** */
- private void testInvalidCardinality(Supplier<Object> supplier, String desc) {
- try {
- supplier.get();
- }
- catch (CardinalityException ce) {
- return;
- }
-
- fail("Expected exception was not caught for " + desc);
- }
-
- /** */
- private boolean readOnly(Matrix m) {
- return m instanceof RandomMatrix;
- }
-
- /** */
- private double[][] fillIntAndReturn(Matrix m) {
- double[][] data = new double[m.rowSize()][m.columnSize()];
-
- if (readOnly(m)) {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- data[i][j] = m.get(i, j);
-
- }
- else {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- data[i][j] = i * m.rowSize() + j + 1;
-
- m.assign(data);
- }
- return data;
- }
-
- /** */
- private double[][] fillAndReturn(Matrix m) {
- double[][] data = new double[m.rowSize()][m.columnSize()];
-
- if (readOnly(m)) {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- data[i][j] = m.get(i, j);
-
- }
- else {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- data[i][j] = -0.5d + Math.random();
-
- m.assign(data);
- }
- return data;
- }
-
- /** */
- private void fillNonSingularMatrix(Matrix m) {
- for (int i = 0; i < m.rowSize(); i++) {
- m.set(i, i, 10);
-
- for (int j = 0; j < m.columnSize(); j++)
- if (j != i)
- m.set(i, j, 0.01d);
- }
- }
-
- /** */
- private void fillMatrix(Matrix m) {
- for (int i = 0; i < m.rowSize(); i++)
- for (int j = 0; j < m.columnSize(); j++)
- m.set(i, j, Math.random());
- }
-
- /** Ignore test for given matrix type. */
- private boolean ignore(Class<? extends Matrix> clazz) {
- List<Class<? extends Matrix>> ignoredClasses = Arrays.asList(RandomMatrix.class, PivotedMatrixView.class,
- MatrixView.class, FunctionMatrix.class, TransposedMatrixView.class);
-
- for (Class<? extends Matrix> ignoredClass : ignoredClasses)
- if (ignoredClass.isAssignableFrom(clazz))
- return true;
-
- return false;
- }
-
- /** */
- private Class<? extends Matrix> likeMatrixType(Matrix m) {
- for (Class<? extends Matrix> clazz : likeTypesMap().keySet())
- if (clazz.isAssignableFrom(m.getClass()))
- return likeTypesMap().get(clazz);
-
- return null;
- }
-
- /** */
- private static Map<Class<? extends Matrix>, Class<? extends Vector>> likeVectorTypesMap() {
- return new LinkedHashMap<Class<? extends Matrix>, Class<? extends Vector>>() {{
- put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapVector.class);
- put(DenseLocalOffHeapMatrix.class, DenseLocalOffHeapVector.class);
- put(RandomMatrix.class, RandomVector.class);
- put(SparseLocalOnHeapMatrix.class, SparseLocalVector.class);
- put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapVector.class);
- put(DiagonalMatrix.class, DenseLocalOnHeapVector.class); // IMPL NOTE per fixture
- // IMPL NOTE check for presence of all implementations here will be done in testHaveLikeMatrix via Fixture
- }};
- }
-
- /** */
- private static Map<Class<? extends Matrix>, Class<? extends Matrix>> likeTypesMap() {
- return new LinkedHashMap<Class<? extends Matrix>, Class<? extends Matrix>>() {{
- put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapMatrix.class);
- put(DenseLocalOffHeapMatrix.class, DenseLocalOffHeapMatrix.class);
- put(RandomMatrix.class, RandomMatrix.class);
- put(SparseLocalOnHeapMatrix.class, SparseLocalOnHeapMatrix.class);
- put(DenseLocalOnHeapMatrix.class, DenseLocalOnHeapMatrix.class);
- put(DiagonalMatrix.class, DenseLocalOnHeapMatrix.class); // IMPL NOTE per fixture
- put(FunctionMatrix.class, FunctionMatrix.class);
- // IMPL NOTE check for presence of all implementations here will be done in testHaveLikeMatrix via Fixture
- }};
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java
deleted file mode 100644
index 90fbec4..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixKeyMapperForTests.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.MatrixKeyMapper;
-
-/** */
-public class MatrixKeyMapperForTests implements MatrixKeyMapper<Integer> {
- /** */ private int rows;
- /** */ private int cols;
-
- /** */
- public MatrixKeyMapperForTests() {
- // No-op.
- }
-
- /** */
- public MatrixKeyMapperForTests(int rows, int cols) {
- this.rows = rows;
- this.cols = cols;
- }
-
- /** */
- @Override public Integer apply(int x, int y) {
- return x * cols + y;
- }
-
- /** */
- @Override public boolean isValid(Integer integer) {
- return (rows * cols) > integer;
- }
-
- /** */
- @Override public int hashCode() {
- int hash = 1;
-
- hash += hash * 31 + rows;
- hash += hash * 31 + cols;
-
- return hash;
- }
-
- /** */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- MatrixKeyMapperForTests that = (MatrixKeyMapperForTests)obj;
-
- return rows == that.rows && cols == that.cols;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java
deleted file mode 100644
index 01278da..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/MatrixViewConstructorTest.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.impls.storage.matrix.MatrixDelegateStorage;
-import org.junit.Test;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class MatrixViewConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- Matrix m = new DenseLocalOnHeapMatrix(1, 1);
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView((Matrix)null, 0, 0, 1, 1),
- "Null parent matrix.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, -1, 0, 1, 1),
- "Invalid row offset.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, 0, -1, 1, 1),
- "Invalid col offset.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, 0, 0, 0, 1),
- "Invalid rows.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new MatrixView(m, 0, 0, 1, 0),
- "Invalid cols.");
- }
-
- /** */
- @Test
- public void basicTest() {
- for (Matrix m : new Matrix[] {
- new DenseLocalOnHeapMatrix(3, 3),
- new DenseLocalOnHeapMatrix(3, 4), new DenseLocalOnHeapMatrix(4, 3)})
- for (int rowOff : new int[] {0, 1})
- for (int colOff : new int[] {0, 1})
- for (int rows : new int[] {1, 2})
- for (int cols : new int[] {1, 2})
- basicTest(m, rowOff, colOff, rows, cols);
- }
-
- /** */
- private void basicTest(Matrix parent, int rowOff, int colOff, int rows, int cols) {
- for (int row = 0; row < parent.rowSize(); row++)
- for (int col = 0; col < parent.columnSize(); col++)
- parent.set(row, col, row * parent.columnSize() + col + 1);
-
- Matrix view = new MatrixView(parent, rowOff, colOff, rows, cols);
-
- assertEquals("Rows in view.", rows, view.rowSize());
- assertEquals("Cols in view.", cols, view.columnSize());
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++)
- assertEquals("Unexpected value at " + row + "x" + col,
- parent.get(row + rowOff, col + colOff), view.get(row, col), 0d);
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++)
- view.set(row, col, 0d);
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++)
- assertEquals("Unexpected value set at " + row + "x" + col,
- 0d, parent.get(row + rowOff, col + colOff), 0d);
- }
-
- /** */
- @Test
- public void attributeTest() {
- for (Matrix m : new Matrix[] {
- new DenseLocalOnHeapMatrix(3, 3),
- new DenseLocalOnHeapMatrix(3, 4), new DenseLocalOnHeapMatrix(4, 3)}) {
- MatrixView matrixView = new MatrixView(m, 0, 0, m.rowSize(), m.columnSize());
-
- MatrixDelegateStorage delegateStorage = (MatrixDelegateStorage)matrixView.getStorage();
-
- assertEquals(m.rowSize(), matrixView.rowSize());
- assertEquals(m.columnSize(), matrixView.columnSize());
-
- assertEquals(m.rowSize(), (delegateStorage).rowsLength());
- assertEquals(m.columnSize(), (delegateStorage).columnsLength());
-
- assertEquals(m.isSequentialAccess(), delegateStorage.isSequentialAccess());
- assertEquals(m.isRandomAccess(), delegateStorage.isRandomAccess());
- assertEquals(m.isDistributed(), delegateStorage.isDistributed());
- assertEquals(m.isDense(), delegateStorage.isDense());
- assertEquals(m.isArrayBased(), delegateStorage.isArrayBased());
-
- assertArrayEquals(m.getStorage().data(), delegateStorage.data());
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java
deleted file mode 100644
index a495745..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/PivotedMatrixViewConstructorTest.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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.matrix;
-
-import java.util.Arrays;
-import org.apache.ignite.math.Matrix;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class PivotedMatrixViewConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- Matrix m = new DenseLocalOnHeapMatrix(1, 1);
-
- int[] pivot = new int[] {0};
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(null),
- "Null parent matrix.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(null, pivot),
- "Null parent matrix, with pivot.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(m, null),
- "Null pivot.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(m, null, pivot),
- "Null row pivot.");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new PivotedMatrixView(m, pivot, null),
- "Null col pivot.");
- }
-
- /** */
- @Test
- public void basicTest() {
- Matrix m = new DenseLocalOnHeapMatrix(2, 2);
-
- int[] pivot = new int[] {0, 1};
-
- PivotedMatrixView view = new PivotedMatrixView(m, pivot);
-
- assertEquals("Rows in view.", m.rowSize(), view.rowSize());
- assertEquals("Cols in view.", m.columnSize(), view.columnSize());
-
- assertTrue("Row pivot array in view.", Arrays.equals(pivot, view.rowPivot()));
- assertTrue("Col pivot array in view.", Arrays.equals(pivot, view.columnPivot()));
-
- assertEquals("Base matrix in view.", m, view.getBaseMatrix());
-
- assertEquals("Row pivot value in view.", 0, view.rowPivot(0));
- assertEquals("Col pivot value in view.", 0, view.columnPivot(0));
-
- assertEquals("Row unpivot value in view.", 0, view.rowUnpivot(0));
- assertEquals("Col unpivot value in view.", 0, view.columnUnpivot(0));
-
- Matrix swap = view.swap(1, 1);
-
- for (int row = 0; row < view.rowSize(); row++)
- for (int col = 0; col < view.columnSize(); col++)
- assertEquals("Unexpected swap value set at (" + row + "," + col + ").",
- view.get(row, col), swap.get(row, col), 0d);
-
- //noinspection EqualsWithItself
- assertTrue("View is expected to be equal to self.", view.equals(view));
- //noinspection ObjectEqualsNull
- assertFalse("View is expected to be not equal to null.", view.equals(null));
- }
-
- /** */
- @Test
- public void pivotTest() {
- int[] pivot = new int[] {2, 1, 0, 3};
-
- for (Matrix m : new Matrix[] {
- new DenseLocalOnHeapMatrix(3, 3),
- new DenseLocalOnHeapMatrix(3, 4), new DenseLocalOnHeapMatrix(4, 3)})
- pivotTest(m, pivot);
- }
-
- /** */
- private void pivotTest(Matrix parent, int[] pivot) {
- for (int row = 0; row < parent.rowSize(); row++)
- for (int col = 0; col < parent.columnSize(); col++)
- parent.set(row, col, row * parent.columnSize() + col + 1);
-
- Matrix view = new PivotedMatrixView(parent, pivot);
-
- int rows = parent.rowSize();
- int cols = parent.columnSize();
-
- assertEquals("Rows in view.", rows, view.rowSize());
- assertEquals("Cols in view.", cols, view.columnSize());
-
- for (int row = 0; row < rows; row++)
- for (int col = 0; col < cols; col++)
- assertEquals("Unexpected value at " + row + "x" + col,
- parent.get(pivot[row], pivot[col]), view.get(row, col), 0d);
-
- int min = rows < cols ? rows : cols;
-
- for (int idx = 0; idx < min; idx++)
- view.set(idx, idx, 0d);
-
- for (int idx = 0; idx < min; idx++)
- assertEquals("Unexpected value set at " + idx,
- 0d, parent.get(pivot[idx], pivot[idx]), 0d);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java
deleted file mode 100644
index e19cfa3..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/matrix/RandomMatrixConstructorTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * 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.matrix;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class RandomMatrixConstructorTest {
- /** */
- @Test
- public void invalidArgsTest() {
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(0, 1), "invalid row parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(1, 0), "invalid col parameter");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(0, 1, true), "invalid row parameter, fastHash true");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(1, 0, true), "invalid col parameter, fastHash true");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(0, 1, false), "invalid row parameter, fastHash false");
-
- DenseLocalOnHeapMatrixConstructorTest.verifyAssertionError(() -> new RandomMatrix(1, 0, false), "invalid col parameter, fastHash false");
- }
-
- /** */
- @Test
- public void basicTest() {
- assertEquals("Expected number of rows, int parameters.", 1,
- new RandomMatrix(1, 2).rowSize());
-
- assertEquals("Expected number of cols, int parameters.", 1,
- new RandomMatrix(2, 1).columnSize());
-
- assertEquals("Expected number of rows, int parameters, fastHash true.", 1,
- new RandomMatrix(1, 2, true).rowSize());
-
- assertEquals("Expected number of cols, int parameters, fastHash true.", 1,
- new RandomMatrix(2, 1, true).columnSize());
-
- assertEquals("Expected number of rows, int parameters, fastHash false.", 1,
- new RandomMatrix(1, 2, false).rowSize());
-
- assertEquals("Expected number of cols, int parameters, fastHash false.", 1,
- new RandomMatrix(2, 1, false).columnSize());
-
- RandomMatrix m = new RandomMatrix(1, 1);
- //noinspection EqualsWithItself
- assertTrue("Matrix is expected to be equal to self.", m.equals(m));
- //noinspection ObjectEqualsNull
- assertFalse("Matrix is expected to be not equal to null.", m.equals(null));
- }
-}
[14/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java
deleted file mode 100644
index 2ed42bc..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/ConstantVectorConstructorTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * 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.vector;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class ConstantVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new ConstantVector(-1, 1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void zeroSizeTest() {
- assertEquals("Zero size.", IMPOSSIBLE_SIZE,
- new ConstantVector(0, 1).size());
- }
-
- /** */
- @Test
- public void primitiveTest() {
- assertEquals("1 size.", 1,
- new ConstantVector(1, 1).size());
-
- assertEquals("2 size.", 2,
- new ConstantVector(2, 1).size());
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java
deleted file mode 100644
index 82e4e0b..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DelegatingVectorConstructorTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Vector;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class DelegatingVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test
- public void basicTest() {
- final Vector parent = new DenseLocalOnHeapVector(new double[] {0, 1});
-
- final Vector delegate = new DelegatingVector(parent);
-
- final int size = parent.size();
-
- assertEquals("Delegate size differs from expected.", size, delegate.size());
-
- for (int idx = 0; idx < size; idx++)
- assertDelegate(parent, delegate, idx);
- }
-
- /** */
- private void assertDelegate(Vector parent, Vector delegate, int idx) {
- assertValue(parent, delegate, idx);
-
- parent.set(idx, parent.get(idx) + 1);
-
- assertValue(parent, delegate, idx);
-
- delegate.set(idx, delegate.get(idx) + 2);
-
- assertValue(parent, delegate, idx);
- }
-
- /** */
- private void assertValue(Vector parent, Vector delegate, int idx) {
- assertEquals("Unexpected value at index " + idx, parent.get(idx), delegate.get(idx), 0d);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java
deleted file mode 100644
index d62f35f..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVectorConstructorTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * 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.vector;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class DenseLocalOffHeapVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new DenseLocalOffHeapVector(-1).size());
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void nullArrayTest() {
- assertEquals("Null array.", IMPOSSIBLE_SIZE,
- new DenseLocalOffHeapVector(null).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void zeroSizeTest() {
- assertEquals("0 size.", IMPOSSIBLE_SIZE,
- new DenseLocalOffHeapVector(new double[0]).size());
- }
-
- /** */
- @Test
- public void primitiveTest() {
- assertEquals("1 size.", 1,
- new DenseLocalOffHeapVector(new double[1]).size());
-
- assertEquals("2 size.", 2,
- new DenseLocalOffHeapVector(new double[2]).size());
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java
deleted file mode 100644
index c10778e..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVectorConstructorTest.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.HashMap;
-import java.util.Map;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class DenseLocalOnHeapVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
- public void mapInvalidArgsTest() {
- assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
- put("invalid", 99);
- }}).size());
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void mapMissingArgsTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("arr", new double[0]);
- put("shallowCopyMissing", "whatever");
- }};
-
- assertEquals("Expect exception due to missing args.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(test).size());
- }
-
- /** */
- @Test(expected = ClassCastException.class)
- public void mapInvalidArrTypeTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("size", "whatever");
- }};
-
- assertEquals("Expect exception due to invalid arr type.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(test).size());
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void mapInvalidCopyTypeTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("arr", new double[0]);
- put("shallowCopy", 0);
- }};
-
- assertEquals("Expect exception due to invalid copy type.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(test).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void mapNullTest() {
- //noinspection ConstantConditions
- assertEquals("Null map args.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector((Map<String, Object>)null).size());
- }
-
- /** */
- @Test
- public void mapTest() {
- assertEquals("Size from args.", 99,
- new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
- put("size", 99);
- }}).size());
-
- final double[] test = new double[99];
-
- assertEquals("Size from array in args.", test.length,
- new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
- put("arr", test);
- put("copy", false);
- }}).size());
-
- assertEquals("Size from array in args, shallow copy.", test.length,
- new DenseLocalOnHeapVector(new HashMap<String, Object>() {{
- put("arr", test);
- put("copy", true);
- }}).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(-1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullCopyTest() {
- assertEquals("Null array to non-shallow copy.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(null, false).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullDefaultCopyTest() {
- assertEquals("Null array default copy.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector((double[])null).size());
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void defaultConstructorTest() {
- assertEquals("Default constructor.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector().size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullArrShallowCopyTest() {
- assertEquals("Null array shallow copy.", IMPOSSIBLE_SIZE,
- new DenseLocalOnHeapVector(null, true).size());
- }
-
- /** */
- @Test
- public void primitiveTest() {
- assertEquals("0 size shallow copy.", 0,
- new DenseLocalOnHeapVector(new double[0], true).size());
-
- assertEquals("0 size.", 0,
- new DenseLocalOnHeapVector(new double[0], false).size());
-
- assertEquals("1 size shallow copy.", 1,
- new DenseLocalOnHeapVector(new double[1], true).size());
-
- assertEquals("1 size.", 1,
- new DenseLocalOnHeapVector(new double[1], false).size());
-
- assertEquals("0 size default copy.", 0,
- new DenseLocalOnHeapVector(new double[0]).size());
-
- assertEquals("1 size default copy.", 1,
- new DenseLocalOnHeapVector(new double[1]).size());
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java
deleted file mode 100644
index 57c96d1..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/FunctionVectorConstructorTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.IntToDoubleFunction;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.functions.IntDoubleToVoidFunction;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class FunctionVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
- public void mapInvalidArgsTest() {
- assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
- new FunctionVector(new HashMap<String, Object>() {{
- put("invalid", 99);
- }}).size());
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void mapMissingArgsTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("size", 1);
- put("paramMissing", "whatever");
- }};
-
- assertEquals("Expect exception due to missing args.",
- -1, new FunctionVector(test).size());
- }
-
- /** */
- @Test(expected = ClassCastException.class)
- public void mapInvalidParamTypeTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("size", "whatever");
-
- put("getFunc", (IntToDoubleFunction)i -> i);
- }};
-
- assertEquals("Expect exception due to invalid param type.", IMPOSSIBLE_SIZE,
- new FunctionVector(test).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void mapNullTest() {
- //noinspection ConstantConditions
- assertEquals("Null map args.", IMPOSSIBLE_SIZE,
- new FunctionVector(null).size());
- }
-
- /** */
- @Test
- public void mapTest() {
- assertEquals("Size from args.", 99,
- new FunctionVector(new HashMap<String, Object>() {{
- put("size", 99);
-
- put("getFunc", (IgniteFunction<Integer, Double>)i -> (double)i);
- }}).size());
-
- assertEquals("Size from args with setFunc.", 99,
- new FunctionVector(new HashMap<String, Object>() {{
- put("size", 99);
-
- put("getFunc", (IgniteFunction<Integer, Double>)i -> (double)i);
-
- put("setFunc", (IntDoubleToVoidFunction)(integer, aDouble) -> {
- });
- }}).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new FunctionVector(-1, (i) -> (double)i).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void zeroSizeTest() {
- assertEquals("0 size.", IMPOSSIBLE_SIZE,
- new FunctionVector(0, (i) -> (double)i).size());
- }
-
- /** */
- @Test
- public void primitiveTest() {
- assertEquals("1 size.", 1,
- new FunctionVector(1, (i) -> (double)i).size());
-
- assertEquals("2 size.", 2,
- new FunctionVector(2, (i) -> (double)i).size());
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java
deleted file mode 100644
index b7e390e..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java
+++ /dev/null
@@ -1,209 +0,0 @@
-package org.apache.ignite.math.impls.vector;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Tests for {@link MatrixVectorView}.
- */
-public class MatrixVectorViewTest {
- /** */
- private static final String UNEXPECTED_VALUE = "Unexpected value";
- /** */
- private static final int SMALL_SIZE = 3;
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- private Matrix parent;
-
- /** */
- @Before
- public void setup() {
- parent = newMatrix(SMALL_SIZE, SMALL_SIZE);
- }
-
- /** */
- @Test
- public void testDiagonal() {
- Vector vector = parent.viewDiagonal();
-
- for (int i = 0; i < SMALL_SIZE; i++)
- assertView(i, i, vector, i);
- }
-
- /** */
- @Test
- public void testRow() {
- for (int i = 0; i < SMALL_SIZE; i++) {
- Vector viewRow = parent.viewRow(i);
-
- for (int j = 0; j < SMALL_SIZE; j++)
- assertView(i, j, viewRow, j);
- }
- }
-
- /** */
- @Test
- public void testCols() {
- for (int i = 0; i < SMALL_SIZE; i++) {
- Vector viewCol = parent.viewColumn(i);
-
- for (int j = 0; j < SMALL_SIZE; j++)
- assertView(j, i, viewCol, j);
- }
- }
-
- /** */
- @Test
- public void basicTest() {
- for (int rowSize : new int[] {1, 2, 3, 4})
- for (int colSize : new int[] {1, 2, 3, 4})
- for (int row = 0; row < rowSize; row++)
- for (int col = 0; col < colSize; col++)
- for (int rowStride = 0; rowStride < rowSize; rowStride++)
- for (int colStride = 0; colStride < colSize; colStride++)
- if (rowStride != 0 || colStride != 0)
- assertMatrixVectorView(newMatrix(rowSize, colSize), row, col, rowStride, colStride);
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void parentNullTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(null, 1, 1, 1, 1).size());
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void rowNegativeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, -1, 1, 1, 1).size());
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void colNegativeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, -1, 1, 1).size());
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void rowTooLargeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, parent.rowSize() + 1, 1, 1, 1).size());
- }
-
- /** */
- @Test(expected = IndexException.class)
- public void colTooLargeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, parent.columnSize() + 1, 1, 1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void rowStrideNegativeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, 1, -1, 1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void colStrideNegativeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, 1, 1, -1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void rowStrideTooLargeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, 1, parent.rowSize() + 1, 1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void colStrideTooLargeTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, 1, 1, parent.columnSize() + 1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void bothStridesZeroTest() {
- //noinspection ConstantConditions
- assertEquals(IMPOSSIBLE_SIZE,
- new MatrixVectorView(parent, 1, 1, 0, 0).size());
- }
-
- /** */
- private void assertMatrixVectorView(Matrix parent, int row, int col, int rowStride, int colStride) {
- MatrixVectorView view = new MatrixVectorView(parent, row, col, rowStride, colStride);
-
- String desc = "parent [" + parent.rowSize() + "x" + parent.columnSize() + "], view ["
- + row + "x" + col + "], strides [" + rowStride + ", " + colStride + "]";
-
- final int size = view.size();
-
- final int sizeByRows = rowStride == 0 ? IMPOSSIBLE_SIZE : (parent.rowSize() - row) / rowStride;
- final int sizeByCols = colStride == 0 ? IMPOSSIBLE_SIZE : (parent.columnSize() - col) / colStride;
-
- assertTrue("Size " + size + " differs from expected for " + desc,
- size == sizeByRows || size == sizeByCols);
-
- for (int idx = 0; idx < size; idx++) {
- final int rowIdx = row + idx * rowStride;
- final int colIdx = col + idx * colStride;
-
- assertEquals(UNEXPECTED_VALUE + " at view index " + idx + desc,
- parent.get(rowIdx, colIdx), view.get(idx), 0d);
- }
- }
-
- /** */
- private Matrix newMatrix(int rowSize, int colSize) {
- Matrix res = new DenseLocalOnHeapMatrix(rowSize, colSize);
-
- for (int i = 0; i < res.rowSize(); i++)
- for (int j = 0; j < res.columnSize(); j++)
- res.set(i, j, i * res.rowSize() + j);
-
- return res;
- }
-
- /** */
- private void assertView(int row, int col, Vector view, int viewIdx) {
- assertValue(row, col, view, viewIdx);
-
- parent.set(row, col, parent.get(row, col) + 1);
-
- assertValue(row, col, view, viewIdx);
-
- view.set(viewIdx, view.get(viewIdx) + 2);
-
- assertValue(row, col, view, viewIdx);
- }
-
- /** */
- private void assertValue(int row, int col, Vector view, int viewIdx) {
- assertEquals(UNEXPECTED_VALUE + " at row " + row + " col " + col, parent.get(row, col), view.get(viewIdx), 0d);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java
deleted file mode 100644
index 91650dc..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.CardinalityException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class PivotedVectorViewConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- private static final SampleParams sampleParams = new SampleParams();
-
- /** */
- @Test(expected = NullPointerException.class)
- public void nullVecParamTest() {
- assertEquals("Expect exception due to null vector param.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(null, sampleParams.pivot).size());
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void nullVecParam2Test() {
- assertEquals("Expect exception due to null vector param, with unpivot.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(null, sampleParams.pivot, sampleParams.unpivot).size());
- }
-
- /** */
- @Test(expected = NullPointerException.class)
- public void nullPivotParamTest() {
- assertEquals("Expect exception due to null pivot param.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, null).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullPivotParam2Test() {
- assertEquals("Expect exception due to null pivot param, with unpivot.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, null, sampleParams.unpivot).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullUnpivotParam2Test() {
- assertEquals("Expect exception due to null unpivot param.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, sampleParams.pivot, null).size());
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void emptyPivotTest() {
- assertEquals("Expect exception due to empty pivot param.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, new int[] {}).size());
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void emptyPivot2Test() {
- assertEquals("Expect exception due to empty pivot param, with unpivot.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, new int[] {}, sampleParams.unpivot).size());
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void wrongPivotTest() {
- assertEquals("Expect exception due to wrong pivot param.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, new int[] {0}).size());
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void wrongPivot2Test() {
- assertEquals("Expect exception due to wrong pivot param, with unpivot.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, new int[] {0}, sampleParams.unpivot).size());
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void emptyUnpivotTest() {
- assertEquals("Expect exception due to empty unpivot param.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, sampleParams.pivot, new int[] {}).size());
- }
-
- /** */
- @Test(expected = CardinalityException.class)
- public void wrongUnpivotTest() {
- assertEquals("Expect exception due to wrong unpivot param, with unpivot.", IMPOSSIBLE_SIZE,
- new PivotedVectorView(sampleParams.vec, sampleParams.pivot, new int[] {0}).size());
- }
-
- /** */
- @Test
- public void basicPivotTest() {
- final PivotedVectorView pvv = new PivotedVectorView(sampleParams.vec, sampleParams.pivot);
-
- final int size = sampleParams.vec.size();
-
- assertEquals("View size differs from expected.", size, pvv.size());
-
- assertSame("Base vector differs from expected.", sampleParams.vec, pvv.getBaseVector());
-
- for (int idx = 0; idx < size; idx++) {
- assertEquals("Sample pivot and unpivot differ from expected",
- idx, sampleParams.unpivot[sampleParams.pivot[idx]]);
-
- assertEquals("Pivot differs from expected at index " + idx,
- sampleParams.pivot[idx], pvv.pivot(idx));
-
- assertEquals("Default unpivot differs from expected at index " + idx,
- sampleParams.unpivot[idx], pvv.unpivot(idx));
-
- final Metric metric = new Metric(sampleParams.vec.get(idx), pvv.get(pvv.pivot(idx)));
-
- assertTrue("Not close enough at index " + idx + ", " + metric, metric.closeEnough());
- }
-
- for (int idx = 0; idx < size; idx++) {
- sampleParams.vec.set(idx, sampleParams.vec.get(idx) + idx + 1);
-
- final Metric metric = new Metric(sampleParams.vec.get(idx), pvv.get(pvv.pivot(idx)));
-
- assertTrue("Modified value not close enough at index " + idx + ", " + metric, metric.closeEnough());
- }
- }
-
- /** */
- @Test
- public void basicUnpivotTest() {
- final PivotedVectorView pvv = new PivotedVectorView(sampleParams.vec, sampleParams.pivot, sampleParams.unpivot);
-
- final int size = sampleParams.vec.size();
-
- assertEquals("View size differs from expected.", size, pvv.size());
-
- for (int idx = 0; idx < size; idx++) {
- assertEquals("Unpivot differs from expected at index " + idx,
- sampleParams.unpivot[idx], pvv.unpivot(idx));
-
- final Metric metric = new Metric(sampleParams.vec.get(idx), pvv.get(pvv.unpivot(idx)));
-
- assertTrue("Not close enough at index " + idx + ", " + metric, metric.closeEnough());
- }
- }
-
- /** */
- private static class SampleParams {
- /** */
- final double[] data = new double[] {0, 1};
- /** */
- final Vector vec = new DenseLocalOnHeapVector(data);
- /** */
- final int[] pivot = new int[] {1, 0};
- /** */
- final int[] unpivot = new int[] {1, 0};
- }
-
- /** */
- private static class Metric { // todo consider if softer tolerance (like say 0.1 or 0.01) would make sense here
- /** */
- private final double exp;
-
- /** */
- private final double obtained;
-
- /** **/
- Metric(double exp, double obtained) {
- this.exp = exp;
- this.obtained = obtained;
- }
-
- /** */
- boolean closeEnough() {
- return new Double(exp).equals(obtained) || closeEnoughToZero();
- }
-
- /** {@inheritDoc} */
- @Override public String toString() {
- return "Metric{" + "expected=" + exp +
- ", obtained=" + obtained +
- '}';
- }
-
- /** */
- private boolean closeEnoughToZero() {
- return (new Double(exp).equals(0.0) && new Double(obtained).equals(-0.0))
- || (new Double(exp).equals(-0.0) && new Double(obtained).equals(0.0));
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java
deleted file mode 100644
index 6d4e4f1..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.HashMap;
-import java.util.Map;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class RandomVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
- public void mapInvalidArgsTest() {
- assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
- new RandomVector(new HashMap<String, Object>() {{
- put("invalid", 99);
- }}).size());
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void mapMissingArgsTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("paramMissing", "whatever");
- }};
-
- assertEquals("Expect exception due to missing args.",
- -1, new RandomVector(test).size());
- }
-
- /** */
- @Test(expected = ClassCastException.class)
- public void mapInvalidParamTypeTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("size", "whatever");
- put("fastHash", true);
- }};
-
- assertEquals("Expect exception due to invalid param type.", IMPOSSIBLE_SIZE,
- new RandomVector(test).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void mapNullTest() {
- //noinspection ConstantConditions
- assertEquals("Null map args.", IMPOSSIBLE_SIZE,
- new RandomVector(null).size());
- }
-
- /** */
- @Test
- public void mapTest() {
- assertEquals("Size from args.", 99,
- new RandomVector(new HashMap<String, Object>() {{
- put("size", 99);
- }}).size());
-
- final int test = 99;
-
- assertEquals("Size from args with fastHash false.", test,
- new RandomVector(new HashMap<String, Object>() {{
- put("size", test);
- put("fastHash", false);
- }}).size());
-
- assertEquals("Size from args with fastHash true.", test,
- new RandomVector(new HashMap<String, Object>() {{
- put("size", test);
- put("fastHash", true);
- }}).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new RandomVector(-1).size());
- }
-
- /** */
- @Test
- public void basicTest() {
- final int basicSize = 3;
-
- Vector v1 = new RandomVector(basicSize);
-
- //noinspection EqualsWithItself
- assertTrue("Expect vector to be equal to self", v1.equals(v1));
-
- //noinspection ObjectEqualsNull
- assertFalse("Expect vector to be not equal to null", v1.equals(null));
-
- assertEquals("Size differs from expected", basicSize, v1.size());
-
- verifyValues(v1);
-
- Vector v2 = new RandomVector(basicSize, true);
-
- assertEquals("Size differs from expected", basicSize, v2.size());
-
- verifyValues(v2);
-
- Vector v3 = new RandomVector(basicSize, false);
-
- assertEquals("Size differs from expected", basicSize, v3.size());
-
- verifyValues(v3);
- }
-
- /** */
- private void verifyValues(Vector v) {
- for (Vector.Element e : v.all()) {
- double val = e.get();
-
- assertTrue("Value too small: " + val + " at index " + e.index(), -1d <= val);
-
- assertTrue("Value too large: " + val + " at index " + e.index(), val <= 1d);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java
deleted file mode 100644
index 69e22e0..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.HashMap;
-import java.util.Map;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class SingleElementVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void mapInvalidArgsTest() {
- assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
- new SingleElementVector(new HashMap<String, Object>() {{
- put("invalid", 99);
- }}).size());
- }
-
- /** */
- @Test(expected = UnsupportedOperationException.class)
- public void mapMissingArgsTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("size", 1);
-
- put("paramMissing", "whatever");
- }};
-
- assertEquals("Expect exception due to missing args.",
- -1, new SingleElementVector(test).size());
- }
-
- /** */
- @Test(expected = ClassCastException.class)
- public void mapInvalidParamTypeTest() {
- final Map<String, Object> test = new HashMap<String, Object>() {{
- put("size", "whatever");
-
- put("index", 0);
- put("value", 1.0);
- }};
-
- assertEquals("Expect exception due to invalid param type.", IMPOSSIBLE_SIZE,
- new SingleElementVector(test).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void mapNullTest() {
- //noinspection ConstantConditions
- assertEquals("Null map args.", IMPOSSIBLE_SIZE,
- new SingleElementVector(null).size());
- }
-
- /** */
- @Test
- public void mapTest() {
- assertEquals("Size from array in args.", 99,
- new SingleElementVector(new HashMap<String, Object>() {{
- put("size", 99);
- put("index", 0);
- put("value", 1.0);
- }}).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new SingleElementVector(-1, 0, 1.0).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void zeroSizeTest() {
- assertEquals("Zero size.", IMPOSSIBLE_SIZE,
- new SingleElementVector(0, 0, 1.0).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void wrongIndexTest() {
- //noinspection ConstantConditions
- assertEquals("Wrong index.", IMPOSSIBLE_SIZE,
- new SingleElementVector(1, 2, 1.0).size());
- }
-
- /** */
- @Test
- public void basicTest() {
- final int[] sizes = new int[] {1, 4, 8};
-
- for (int size : sizes)
- for (int idx = 0; idx < size; idx++)
- basicTest(size, idx);
- }
-
- /** */
- private void basicTest(int size, int idx) {
- final Double expVal = (double)(size - idx);
-
- Vector v = new SingleElementVector(size, idx, expVal);
-
- assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
- expVal.equals(v.get(idx)));
-
- final double delta = 1.0;
-
- v.set(idx, expVal - delta);
-
- assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
- expVal.equals(v.get(idx) + delta));
-
- final Double zero = 0.0;
-
- for (int i = 0; i < size; i++) {
- if (i == idx)
- continue;
-
- assertTrue("Expect zero at index " + i + " for size " + size,
- zero.equals(v.get(i)));
-
- boolean eCaught = false;
-
- try {
- v.set(i, 1.0);
- }
- catch (UnsupportedOperationException uoe) {
- eCaught = true;
- }
-
- assertTrue("Expect " + java.lang.UnsupportedOperationException.class.getSimpleName()
- + " at index " + i + " for size " + size, eCaught);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java
deleted file mode 100644
index 957f3b7..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-/** */
-public class SingleElementVectorViewConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- private static final SampleHelper helper = new SampleHelper();
-
- /** */
- @Test(expected = AssertionError.class)
- public void nullVecParamTest() {
- assertEquals("Expect exception due to null vector param.", IMPOSSIBLE_SIZE,
- new SingleElementVectorView(null, helper.idx).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeIdxParamTest() {
- assertEquals("Expect exception due to negative index param.", IMPOSSIBLE_SIZE,
- new SingleElementVectorView(helper.vec, -1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void tooLargeIdxParamTest() {
- assertEquals("Expect exception due to too large index param.", IMPOSSIBLE_SIZE,
- new SingleElementVectorView(helper.vec, helper.vec.size()).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void emptyVecParamTest() {
- assertEquals("Expect exception due to empty vector param.", IMPOSSIBLE_SIZE,
- new SingleElementVectorView(helper.vecEmpty, 0).size());
- }
-
- /** */
- @Test
- public void basicTest() {
- final int[] sizes = new int[] {1, 4, 8};
-
- for (int size : sizes)
- for (int idx = 0; idx < size; idx++)
- basicTest(size, idx);
- }
-
- /** */
- private void basicTest(int size, int idx) {
- final Double expVal = (double)(size - idx);
-
- Vector orig = helper.newSample(size, idx, expVal);
-
- SingleElementVectorView svv = new SingleElementVectorView(orig, idx);
-
- assertEquals("Size differs from expected", size, svv.size());
-
- assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
- expVal.equals(svv.get(idx)));
-
- final double delta = 1.0;
-
- svv.set(idx, expVal - delta);
-
- assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
- expVal.equals(orig.get(idx) + delta));
-
- final Double zero = 0.0;
-
- for (int i = 0; i < size; i++) {
- if (i == idx)
- continue;
-
- assertTrue("Expect zero at index " + i + " for size " + size,
- zero.equals(svv.get(i)));
-
- boolean eCaught = false;
-
- try {
- svv.set(i, 1.0);
- }
- catch (UnsupportedOperationException uoe) {
- eCaught = true;
- }
-
- assertTrue("Expect " + UnsupportedOperationException.class.getSimpleName()
- + " at index " + i + " for size " + size, eCaught);
- }
- }
-
- /** */
- private static class SampleHelper {
- /** */
- final double[] data = new double[] {0, 1};
- /** */
- final Vector vec = new DenseLocalOnHeapVector(data);
- /** */
- final Vector vecEmpty = new DenseLocalOnHeapVector(new double[] {});
- /** */
- final int idx = 0;
-
- /** */
- Vector newSample(int size, int idx, double expVal) {
- final Vector v = new DenseLocalOnHeapVector(size);
-
- for (int i = 0; i < size; i++)
- v.set(i, i == idx ? expVal : i);
-
- return v;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java
deleted file mode 100644
index 2be4a10..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.StorageConstants;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class SparseLocalVectorConstructorTest {
- /** */
- private static final int IMPOSSIBLE_SIZE = -1;
-
- /** */
- @Test(expected = AssertionError.class)
- public void negativeSizeTest() {
- assertEquals("Negative size.", IMPOSSIBLE_SIZE,
- new SparseLocalVector(-1, 1).size());
- }
-
- /** */
- @Test(expected = AssertionError.class)
- public void zeroSizeTest() {
- assertEquals("0 size.", IMPOSSIBLE_SIZE,
- new SparseLocalVector(0, 1).size());
- }
-
- /** */
- @Test
- public void primitiveTest() {
- assertEquals("1 size, random access.", 1,
- new SparseLocalVector(1, StorageConstants.RANDOM_ACCESS_MODE).size());
-
- assertEquals("1 size, sequential access.", 1,
- new SparseLocalVector(1, StorageConstants.SEQUENTIAL_ACCESS_MODE).size());
-
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java
deleted file mode 100644
index 992018a..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.function.Function;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-/** */
-public class VectorAttributesTest {
- /** */
- private final List<AttrCfg> attrCfgs = Arrays.asList(
- new AttrCfg("isDense", Vector::isDense,
- DenseLocalOnHeapVector.class, DenseLocalOffHeapVector.class, RandomVector.class, ConstantVector.class,
- SingleElementVector.class),
- new AttrCfg("isArrayBased", Vector::isArrayBased,
- DenseLocalOnHeapVector.class),
- new AttrCfg("isSequentialAccess", Vector::isSequentialAccess,
- DenseLocalOnHeapVector.class, DenseLocalOffHeapVector.class, SparseLocalVectorSequentialAccess.class,
- RandomVector.class, ConstantVector.class, SingleElementVector.class),
- new AttrCfg("guidNotNull", v -> v.guid() == null), // IMPL NOTE this is somewhat artificial
- new AttrCfg("isRandomAccess", Vector::isRandomAccess,
- DenseLocalOnHeapVector.class, DenseLocalOffHeapVector.class, RandomVector.class, ConstantVector.class,
- SingleElementVector.class, SparseLocalVectorSequentialAccess.class, SparseLocalVectorRandomAccess.class),
- new AttrCfg("isDistributed", Vector::isDistributed));
-
- /** */
- private final List<Specification> specFixture = Arrays.asList(
- new Specification(new DenseLocalOnHeapVector(1)),
- new Specification(new DenseLocalOffHeapVector(1)),
- new Specification(new DelegatingVector(new DenseLocalOnHeapVector(1)),
- DenseLocalOnHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
- "isRandomAccess", "isDistributed"),
- new Specification(new DelegatingVector(new DenseLocalOffHeapVector(1)),
- DenseLocalOffHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
- "isRandomAccess", "isDistributed"),
- new Specification(new SparseLocalVectorSequentialAccess(1)),
- new Specification(new SparseLocalVectorRandomAccess(1)),
- new Specification(new RandomVector(1)),
- new Specification(new ConstantVector(1, 1.0)),
- new Specification(new FunctionVector(1, idx -> (double)idx)),
- new Specification(new SingleElementVector(1, 0, 1.0)),
- new Specification(new PivotedVectorView(new DenseLocalOnHeapVector(1), new int[] {0}),
- DenseLocalOnHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
- "isRandomAccess", "isDistributed"),
- new Specification(new PivotedVectorView(new DenseLocalOffHeapVector(1), new int[] {0}),
- DenseLocalOffHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
- "isRandomAccess", "isDistributed"),
- new Specification(new SingleElementVectorView(new DenseLocalOnHeapVector(1), 0),
- DenseLocalOnHeapVector.class, "isDense", "isSequentialAccess",
- "isRandomAccess", "isDistributed"),
- new Specification(new SingleElementVectorView(new DenseLocalOffHeapVector(1), 0),
- DenseLocalOffHeapVector.class, "isDense", "isSequentialAccess",
- "isRandomAccess", "isDistributed"),
- new Specification(new MatrixVectorView(new DenseLocalOnHeapMatrix(1, 1), 0, 0, 1, 1),
- DenseLocalOnHeapVector.class, "isDense",
- "isRandomAccess", "isDistributed"), // todo find out why "isSequentialAccess" fails here
- new Specification(new MatrixVectorView(new DenseLocalOffHeapMatrix(1, 1), 0, 0, 1, 1),
- DenseLocalOffHeapVector.class, "isDense",
- "isRandomAccess", "isDistributed"));
-
- /** */
- @Test
- public void isDenseTest() {
- assertAttribute("isDense");
- }
-
- /** */
- @Test
- public void isArrayBasedTest() {
- assertAttribute("isArrayBased");
- }
-
- /** */
- @Test
- public void isSequentialAccessTest() {
- assertAttribute("isSequentialAccess");
- }
-
- /** */
- @Test
- public void guidTest() {
- assertAttribute("guidNotNull");
- }
-
- /** */
- @Test
- public void isRandomAccessTest() {
- assertAttribute("isRandomAccess");
- }
-
- /** */
- @Test
- public void isDistributedTest() {
- assertAttribute("isDistributed");
- }
-
- /** */
- private void assertAttribute(String name) {
- final AttrCfg attr = attrCfg(name);
-
- for (Specification spec : specFixture)
- spec.verify(attr);
- }
-
- /** */
- private AttrCfg attrCfg(String name) {
- for (AttrCfg attr : attrCfgs)
- if (attr.name.equals(name))
- return attr;
-
- throw new IllegalArgumentException("Undefined attribute " + name);
- }
-
- /** See http://en.wikipedia.org/wiki/Specification_pattern */
- private static class Specification {
- /** */
- private final Vector v;
- /** */
- private final Class<? extends Vector> underlyingType;
- /** */
- private final List<String> attrsFromUnderlying;
- /** */
- final String desc;
-
- /** */
- Specification(Vector v, Class<? extends Vector> underlyingType, String... attrsFromUnderlying) {
- this.v = v;
- this.underlyingType = underlyingType;
- this.attrsFromUnderlying = Arrays.asList(attrsFromUnderlying);
- final Class<? extends Vector> clazz = v.getClass();
- desc = clazz.getSimpleName() + (clazz.equals(underlyingType)
- ? "" : " (underlying type " + underlyingType.getSimpleName() + ")");
- }
-
- /** */
- Specification(Vector v) {
- this(v, v.getClass());
- }
-
- /** */
- void verify(AttrCfg attr) {
- final boolean obtained = attr.obtain.apply(v);
-
- final Class<? extends Vector> typeToCheck
- = attrsFromUnderlying.contains(attr.name) ? underlyingType : v.getClass();
-
- final boolean exp = attr.trueInTypes.contains(typeToCheck);
-
- assertEquals("Unexpected " + attr.name + " value for " + desc, exp, obtained);
- }
- }
-
- /** */
- private static class AttrCfg {
- /** */
- final String name;
- /** */
- final Function<Vector, Boolean> obtain;
- /** */
- final List<Class> trueInTypes;
-
- /** */
- AttrCfg(String name, Function<Vector, Boolean> obtain, Class... trueInTypes) {
- this.name = name;
- this.obtain = obtain;
- this.trueInTypes = Arrays.asList(trueInTypes);
- }
- }
-
- /** */
- private static class SparseLocalVectorSequentialAccess extends SparseLocalVector {
- /** */
- public SparseLocalVectorSequentialAccess() {
- // No-op.
- }
-
- /** */
- SparseLocalVectorSequentialAccess(int size) {
- super(size, SEQUENTIAL_ACCESS_MODE);
- }
- }
-
- /** */
- private static class SparseLocalVectorRandomAccess extends SparseLocalVector {
- /** */
- public SparseLocalVectorRandomAccess() {
- // No-op.
- }
-
- /** */
- SparseLocalVectorRandomAccess(int size) {
- super(size, RANDOM_ACCESS_MODE);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java b/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java
deleted file mode 100644
index 67eb8ba..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Arrays;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.functions.Functions;
-import org.junit.Test;
-
-import static java.util.function.DoubleUnaryOperator.identity;
-import static org.junit.Assert.assertTrue;
-
-/** See also: {@link AbstractVectorTest} and {@link VectorToMatrixTest}. */
-public class VectorFoldMapTest {
- /** */
- @Test
- public void mapVectorTest() {
- operationVectorTest((operand1, operand2) -> operand1 + operand2, (Vector v1, Vector v2) -> v1.map(v2, Functions.PLUS));
- }
-
- /** */
- @Test
- public void mapDoubleFunctionTest() {
- consumeSampleVectors((v, desc) -> operatorTest(v, desc,
- (vec) -> vec.map(Functions.INV), (val) -> 1.0 / val));
- }
-
- /** */
- @Test
- public void mapBiFunctionTest() {
- consumeSampleVectors((v, desc) -> operatorTest(v, desc,
- (vec) -> vec.map(Functions.PLUS, 1.0), (val) -> 1.0 + val));
- }
-
- /** */
- @Test
- public void foldMapTest() {
- toDoubleTest(
- ref -> Arrays.stream(ref).map(identity()).sum(),
- (v) -> v.foldMap(Functions.PLUS, Functions.IDENTITY, 0.0));
- }
-
- /** */
- @Test
- public void foldMapVectorTest() {
- toDoubleTest(
- ref -> 2.0 * Arrays.stream(ref).sum(),
- (v) -> v.foldMap(v, Functions.PLUS, Functions.PLUS, 0.0));
-
- }
-
- /** */
- private void operatorTest(Vector v, String desc, Function<Vector, Vector> op, Function<Double, Double> refOp) {
- final int size = v.size();
- final double[] ref = new double[size];
-
- VectorImplementationsTest.ElementsChecker checker = new VectorImplementationsTest.ElementsChecker(v, ref, desc);
-
- Vector actual = op.apply(v);
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = refOp.apply(ref[idx]);
-
- checker.assertCloseEnough(actual, ref);
- }
-
- /** */
- private void toDoubleTest(Function<double[], Double> calcRef, Function<Vector, Double> calcVec) {
- consumeSampleVectors((v, desc) -> {
- final int size = v.size();
- final double[] ref = new double[size];
-
- new VectorImplementationsTest.ElementsChecker(v, ref, desc); // IMPL NOTE this initialises vector and reference array
-
- final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(calcRef.apply(ref), calcVec.apply(v));
-
- assertTrue("Not close enough at " + desc
- + ", " + metric, metric.closeEnough());
- });
- }
-
- /** */
- private void operationVectorTest(BiFunction<Double, Double, Double> operation,
- BiFunction<Vector, Vector, Vector> vecOperation) {
- consumeSampleVectors((v, desc) -> {
- // TODO find out if more elaborate testing scenario is needed or it's okay as is.
- final int size = v.size();
- final double[] ref = new double[size];
-
- final VectorImplementationsTest.ElementsChecker checker = new VectorImplementationsTest.ElementsChecker(v, ref, desc);
- final Vector operand = v.copy();
-
- for (int idx = 0; idx < size; idx++)
- ref[idx] = operation.apply(ref[idx], ref[idx]);
-
- checker.assertCloseEnough(vecOperation.apply(v, operand), ref);
- });
- }
-
- /** */
- private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
- new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
- }
-}
[22/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java
deleted file mode 100644
index 66fe13c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/EigenDecomposition.java
+++ /dev/null
@@ -1,923 +0,0 @@
-/*
- * 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;
-
-/**
- * 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/732dfea9/modules/math/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java
deleted file mode 100644
index 82c90ec..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/LUDecomposition.java
+++ /dev/null
@@ -1,366 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java
deleted file mode 100644
index 9608ed5..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/QRDecomposition.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java
deleted file mode 100644
index 75eb206..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/SingularValueDecomposition.java
+++ /dev/null
@@ -1,620 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/decompositions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/package-info.java
deleted file mode 100644
index dcfa0f8..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java
deleted file mode 100644
index fc87a27..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/CardinalityException.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java
deleted file mode 100644
index 7670caf..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/ColumnIndexException.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/IndexException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/IndexException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/IndexException.java
deleted file mode 100644
index 9ada706..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/IndexException.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java
deleted file mode 100644
index b6017c2..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/NonPositiveDefiniteMatrixException.java
+++ /dev/null
@@ -1,20 +0,0 @@
-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/math/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java
deleted file mode 100644
index 8b4cbdb..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/NonSymmetricMatrixException.java
+++ /dev/null
@@ -1,18 +0,0 @@
-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/math/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java
deleted file mode 100644
index f74ae2c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/RowIndexException.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java
deleted file mode 100644
index 4ed3410..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/SingularMatrixException.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java
deleted file mode 100644
index 3e6498a..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/UnknownProviderException.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java
deleted file mode 100644
index be5264c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/UnsupportedOperationException.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * 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/math/src/main/java/org/apache/ignite/math/exceptions/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/exceptions/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/exceptions/package-info.java
deleted file mode 100644
index 83f3fa4..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/exceptions/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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
[20/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java
deleted file mode 100644
index 2c3dcb2..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/RandomMatrix.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * 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.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.storage.matrix.RandomMatrixStorage;
-import org.apache.ignite.math.impls.vector.RandomVector;
-
-/**
- * Implementation of {@link Matrix} with random values in the elements.
- */
-public class RandomMatrix extends AbstractMatrix {
- /** Whether fast hash is used, see {@link RandomMatrixStorage}. */
- private boolean fastHash;
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param fastHash Whether fast hash is used.
- */
- private MatrixStorage mkStorage(int rows, int cols, boolean fastHash) {
- this.fastHash = fastHash;
-
- return new RandomMatrixStorage(rows, cols, fastHash);
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param fastHash Whether fast hash is used.
- */
- public RandomMatrix(int rows, int cols, boolean fastHash) {
- setStorage(mkStorage(rows, cols, fastHash));
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- */
- public RandomMatrix(int rows, int cols) {
- this(rows, cols, true);
- }
-
- /** */
- public RandomMatrix() {
- // No-op.
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- return new RandomMatrix(rowSize(), columnSize(), fastHash);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- return new RandomMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- return new RandomVector(crd);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeBoolean(fastHash);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- fastHash = in.readBoolean();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java
deleted file mode 100644
index 5c40d70..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseDistributedMatrix.java
+++ /dev/null
@@ -1,155 +0,0 @@
-// @java.file.header
-
-/* _________ _____ __________________ _____
- * __ ____/___________(_)______ /__ ____/______ ____(_)_______
- * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
- * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
- * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
- */
-
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.impls.CacheUtils;
-import org.apache.ignite.math.impls.storage.matrix.SparseDistributedMatrixStorage;
-
-/**
- * Sparse distributed matrix implementation based on data grid.
- *
- * Unlike {@link CacheMatrix} that is based on existing cache, this implementation creates distributed
- * cache internally and doesn't rely on pre-existing cache.
- *
- * You also need to call {@link #destroy()} to remove the underlying cache when you no longer need this
- * matrix.
- *
- * <b>Currently fold supports only commutative operations.<b/>
- */
-public class SparseDistributedMatrix extends AbstractMatrix implements StorageConstants {
- /**
- *
- */
- public SparseDistributedMatrix() {
- // No-op.
- }
-
- /**
- * @param rows
- * @param cols
- * @param stoMode
- * @param acsMode
- */
- public SparseDistributedMatrix(int rows, int cols, int stoMode, int acsMode) {
- assert rows > 0;
- assert cols > 0;
- assertAccessMode(acsMode);
- assertStorageMode(stoMode);
-
- setStorage(new SparseDistributedMatrixStorage(rows, cols, stoMode, acsMode));
- }
-
- /**
- *
- *
- */
- private SparseDistributedMatrixStorage storage() {
- return (SparseDistributedMatrixStorage)getStorage();
- }
-
- /**
- * Return the same matrix with updates values (broken contract).
- *
- * @param d
- */
- @Override public Matrix divide(double d) {
- return mapOverValues((Double v) -> v / d);
- }
-
- /**
- * Return the same matrix with updates values (broken contract).
- *
- * @param x
- */
- @Override public Matrix plus(double x) {
- return mapOverValues((Double v) -> v + x);
- }
-
- /**
- * Return the same matrix with updates values (broken contract).
- *
- * @param x
- */
- @Override public Matrix times(double x) {
- return mapOverValues((Double v) -> v * x);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix assign(double val) {
- return mapOverValues((Double v) -> val);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix map(IgniteDoubleFunction<Double> fun) {
- return mapOverValues(fun::apply);
- }
-
- /**
- * @param mapper
- */
- private Matrix mapOverValues(IgniteFunction<Double, Double> mapper) {
- CacheUtils.sparseMap(storage().cache().getName(), mapper);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- return CacheUtils.sparseSum(storage().cache().getName());
- }
-
- /** {@inheritDoc} */
- @Override public double maxValue() {
- return CacheUtils.sparseMax(storage().cache().getName());
- }
-
- /** {@inheritDoc} */
- @Override public double minValue() {
- return CacheUtils.sparseMin(storage().cache().getName());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java
deleted file mode 100644
index cb08939..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/SparseLocalOnHeapMatrix.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.storage.matrix.SparseLocalOnHeapMatrixStorage;
-import org.apache.ignite.math.impls.vector.SparseLocalVector;
-
-/**
- * Sparse local onheap matrix with {@link SparseLocalVector} as rows.
- */
-public class SparseLocalOnHeapMatrix extends AbstractMatrix implements StorageConstants {
- /**
- *
- */
- public SparseLocalOnHeapMatrix() {
- // No-op.
- }
-
- /**
- * Construct new {@link SparseLocalOnHeapMatrix}.
- *
- * By default storage sets in row optimized mode and in random access mode.
- */
- public SparseLocalOnHeapMatrix(int rows, int cols) {
- setStorage(mkStorage(rows, cols));
- }
-
- /**
- * Create new {@link SparseLocalOnHeapMatrixStorage}.
- */
- private MatrixStorage mkStorage(int rows, int cols) {
- return new SparseLocalOnHeapMatrixStorage(rows, cols, StorageConstants.RANDOM_ACCESS_MODE, StorageConstants.ROW_STORAGE_MODE);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- return new SparseLocalOnHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- return new SparseLocalVector(crd, StorageConstants.RANDOM_ACCESS_MODE);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- Matrix cp = like(rowSize(), columnSize());
-
- cp.assign(this);
-
- return cp;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java
deleted file mode 100644
index 9da909b..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/TransposedMatrixView.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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.matrix;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.storage.matrix.MatrixDelegateStorage;
-
-/**
- * Implements transposed view of the parent {@link Matrix}.
- */
-public class TransposedMatrixView extends AbstractMatrix {
- /** */
- public TransposedMatrixView() {
- //No-op.
- }
-
- /**
- * @param mtx Parent matrix.
- */
- public TransposedMatrixView(Matrix mtx) {
- this(mtx == null ? null : mtx.getStorage());
- }
-
- /** */
- private TransposedMatrixView(MatrixStorage sto) {
- super(new MatrixDelegateStorage(sto, 0, 0,
- sto == null ? 0 : sto.rowSize(), sto == null ? 0 : sto.columnSize()));
- }
-
- /** {@inheritDoc} */
- @Override protected void storageSet(int row, int col, double v) {
- super.storageSet(col, row, v);
- }
-
- /** {@inheritDoc} */
- @Override protected double storageGet(int row, int col) {
- return super.storageGet(col, row);
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return getStorage().columnSize();
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return getStorage().rowSize();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix copy() {
- MatrixDelegateStorage sto = (MatrixDelegateStorage)getStorage();
-
- return new TransposedMatrixView(sto.delegate());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix like(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Vector likeVector(int crd) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java
deleted file mode 100644
index 75d7532..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/matrix/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 several matrix implementations.
- */
-package org.apache.ignite.math.impls.matrix;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/impls/package-info.java
deleted file mode 100644
index f1b2e36..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 specific implementations for core algebra.
- */
-package org.apache.ignite.math.impls;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java
deleted file mode 100644
index eb65b1d..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/ArrayMatrixStorage.java
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import org.apache.ignite.math.MatrixStorage;
-
-/**
- * Array based {@link MatrixStorage} implementation.
- */
-public class ArrayMatrixStorage implements MatrixStorage {
- /** Backing data array. */
- private double[][] data;
- /** Amount of rows in the matrix. */
- private int rows;
- /** Amount of columns in the matrix. */
- private int cols;
-
- /**
- *
- */
- public ArrayMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- */
- public ArrayMatrixStorage(int rows, int cols) {
- assert rows > 0;
- assert cols > 0;
-
- this.data = new double[rows][cols];
- this.rows = rows;
- this.cols = cols;
- }
-
- /**
- * @param data Backing data array.
- */
- public ArrayMatrixStorage(double[][] data) {
- assert data != null;
- assert data[0] != null;
-
- this.data = data;
- this.rows = data.length;
- this.cols = data[0].length;
-
- assert rows > 0;
- assert cols > 0;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return data[x][y];
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- data[x][y] = v;
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public double[][] data() {
- return data;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
-
- out.writeObject(data);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
-
- data = (double[][])in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res += res * 37 + rows;
- res += res * 37 + cols;
- res += res * 37 + Arrays.deepHashCode(data);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- ArrayMatrixStorage that = (ArrayMatrixStorage)o;
-
- return Arrays.deepEquals(data, that.data);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java
deleted file mode 100644
index 7aefa2c..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/CacheMatrixStorage.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.Ignition;
-import org.apache.ignite.math.MatrixKeyMapper;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.ValueMapper;
-
-/**
- * Matrix storage based on arbitrary cache and key and value mapping functions.
- */
-public class CacheMatrixStorage<K, V> implements MatrixStorage {
- /** */ private int rows;
- /** */ private int cols;
- /** */ private IgniteCache<K, V> cache;
- /** */ private MatrixKeyMapper<K> keyMapper;
- /** */ private ValueMapper<V> valMapper;
-
- /**
- *
- */
- public CacheMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param rows
- * @param cols
- * @param cache
- * @param keyMapper
- * @param valMapper
- */
- public CacheMatrixStorage(int rows, int cols, IgniteCache<K, V> cache, MatrixKeyMapper<K> keyMapper,
- ValueMapper<V> valMapper) {
- assert rows > 0;
- assert cols > 0;
- assert cache != null;
- assert keyMapper != null;
- assert valMapper != null;
-
- this.rows = rows;
- this.cols = cols;
- this.cache = cache;
- this.keyMapper = keyMapper;
- this.valMapper = valMapper;
- }
-
- /**
- * @return Ignite cache.
- */
- public IgniteCache<K, V> cache() {
- return cache;
- }
-
- /**
- * @return Key mapper.
- */
- public MatrixKeyMapper<K> keyMapper() {
- return keyMapper;
- }
-
- /**
- * @return Value mapper.
- */
- public ValueMapper<V> valueMapper() {
- return valMapper;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return valMapper.toDouble(cache.get(keyMapper.apply(x, y)));
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- cache.put(keyMapper.apply(x, y), valMapper.fromDouble(v));
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
- out.writeUTF(cache.getName());
- out.writeObject(keyMapper);
- out.writeObject(valMapper);
- }
-
- /** {@inheritDoc} */
- @SuppressWarnings({"unchecked"})
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
- cache = Ignition.localIgnite().getOrCreateCache(in.readUTF());
- keyMapper = (MatrixKeyMapper<K>)in.readObject();
- valMapper = (ValueMapper<V>)in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + rows;
- res = res * 37 + cols;
- res = res * 37 + cache.hashCode();
- res = res * 37 + keyMapper.hashCode();
- res = res * 37 + valMapper.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- CacheMatrixStorage that = (CacheMatrixStorage)o;
-
- return (cache != null ? cache.equals(that.cache) : that.cache == null) &&
- (keyMapper != null ? keyMapper.equals(that.keyMapper) : that.keyMapper == null) &&
- (valMapper != null ? valMapper.equals(that.valMapper) : that.valMapper == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java
deleted file mode 100644
index 6695bc2..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DenseOffHeapMatrixStorage.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.internal.util.GridUnsafe;
-import org.apache.ignite.math.MatrixStorage;
-
-/**
- * Local, dense off-heap matrix storage.
- */
-public class DenseOffHeapMatrixStorage implements MatrixStorage {
- /** */ private int rows;
- /** */ private int cols;
- /** */ private transient long ptr;
- //TODO: temp solution.
- /** */ private int ptrInitHash;
-
- /** */
- public DenseOffHeapMatrixStorage() {
- // No-op.
- }
-
- /** */
- public DenseOffHeapMatrixStorage(int rows, int cols) {
- assert rows > 0;
- assert cols > 0;
-
- this.rows = rows;
- this.cols = cols;
-
- allocateMemory(rows, cols);
- }
-
- /** */
- public DenseOffHeapMatrixStorage(double[][] data) {
- assert data != null;
- assert data[0] != null;
-
- this.rows = data.length;
- this.cols = data[0].length;
-
- assert rows > 0;
- assert cols > 0;
-
- allocateMemory(rows, cols);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- set(i, j, data[i][j]);
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return GridUnsafe.getDouble(pointerOffset(x, y));
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- GridUnsafe.putDouble(pointerOffset(x, y), v);
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public double[][] data() {
- return null;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
- out.writeInt(ptrInitHash);
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- out.writeDouble(get(i, j));
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
-
- allocateMemory(rows, cols);
-
- ptrInitHash = in.readInt();
-
- for (int i = 0; i < rows; i++)
- for (int j = 0; j < cols; j++)
- set(i, j, in.readDouble());
- }
-
- /** {@inheritDoc} */
- @Override public void destroy() {
- GridUnsafe.freeMemory(ptr);
- }
-
- /** {@inheritDoc} */
- private long pointerOffset(int x, int y) {
- return ptr + x * cols * Double.BYTES + y * Double.BYTES;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- return obj != null &&
- getClass().equals(obj.getClass()) &&
- (rows == ((DenseOffHeapMatrixStorage)obj).rows) &&
- (cols == ((DenseOffHeapMatrixStorage)obj).cols) &&
- (rows == 0 || cols == 0 || ptr == ((DenseOffHeapMatrixStorage)obj).ptr || isMemoryEquals((DenseOffHeapMatrixStorage)obj));
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + rows;
- res = res * 37 + cols;
- res = res * 37 + ptrInitHash;
-
- return res;
- }
-
- /** */
- private boolean isMemoryEquals(DenseOffHeapMatrixStorage otherStorage) {
- boolean res = true;
-
- for (int i = 0; i < otherStorage.rows; i++) {
- for (int j = 0; j < otherStorage.cols; j++) {
- if (Double.compare(get(i, j), otherStorage.get(i, j)) != 0) {
- res = false;
- break;
- }
- }
- }
-
- return res;
- }
-
- /** */
- private void allocateMemory(int rows, int cols) {
- ptr = GridUnsafe.allocateMemory(rows * cols * Double.BYTES);
-
- ptrInitHash = Long.hashCode(ptr);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java
deleted file mode 100644
index 099db38..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * {@link MatrixStorage} implementation for diagonal Matrix view.
- */
-public class DiagonalMatrixStorage implements MatrixStorage {
- /** Backing vector for matrix diagonal. */
- private Vector diagonal;
-
- /**
- *
- */
- public DiagonalMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param diagonal Backing {@link Vector} for matrix diagonal.
- */
- public DiagonalMatrixStorage(Vector diagonal) {
- assert diagonal != null;
-
- this.diagonal = diagonal;
- }
-
- /**
- *
- */
- public Vector diagonal() {
- return diagonal;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return x == y ? diagonal.get(x) : 0.0;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- if (x == y)
- diagonal.set(x, v);
- else
- throw new UnsupportedOperationException("Can't set off-diagonal element.");
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return diagonal.size();
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return diagonal.size();
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(diagonal);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- diagonal = (Vector)in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return diagonal.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return diagonal.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return diagonal.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return diagonal.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + diagonal.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- DiagonalMatrixStorage that = (DiagonalMatrixStorage)o;
-
- return diagonal.equals(that.diagonal);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java
deleted file mode 100644
index 6b0c6b4..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IntIntDoubleToVoidFunction;
-import org.apache.ignite.math.functions.IntIntToDoubleFunction;
-
-/**
- * Read-only or read-write function-based matrix storage.
- */
-public class FunctionMatrixStorage implements MatrixStorage {
- /** */ private int rows;
- /** */ private int cols;
-
- /** */ private IntIntToDoubleFunction getFunc;
- /** */ private IntIntDoubleToVoidFunction setFunc;
-
- /**
- *
- */
- public FunctionMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param getFunc Function that returns value corresponding to given row and column index.
- * @param setFunc Set function. If {@code null} - this will be a read-only matrix.
- */
- public FunctionMatrixStorage(int rows, int cols, IntIntToDoubleFunction getFunc,
- IntIntDoubleToVoidFunction setFunc) {
- assert rows > 0;
- assert cols > 0;
- assert getFunc != null;
-
- this.rows = rows;
- this.cols = cols;
- this.getFunc = getFunc;
- this.setFunc = setFunc;
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param getFunc Function that returns value corresponding to given row and column index.
- */
- public FunctionMatrixStorage(int rows, int cols, IntIntToDoubleFunction getFunc) {
- this(rows, cols, getFunc, null);
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return getFunc.apply(x, y);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- if (setFunc != null)
- setFunc.apply(x, y, v);
- else
- throw new UnsupportedOperationException("Cannot set into read-only matrix.");
- }
-
- /**
- *
- */
- public IntIntToDoubleFunction getFunction() {
- return getFunc;
- }
-
- /**
- *
- */
- public IntIntDoubleToVoidFunction setFunction() {
- return setFunc;
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(setFunc);
- out.writeObject(getFunc);
- out.writeInt(rows);
- out.writeInt(cols);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- setFunc = (IntIntDoubleToVoidFunction)in.readObject();
- getFunc = (IntIntToDoubleFunction)in.readObject();
- rows = in.readInt();
- cols = in.readInt();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- FunctionMatrixStorage that = (FunctionMatrixStorage)o;
-
- return rows == that.rows && cols == that.cols
- && (getFunc != null ? getFunc.equals(that.getFunc) : that.getFunc == null)
- && (setFunc != null ? setFunc.equals(that.setFunc) : that.setFunc == null);
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = rows;
-
- res = 31 * res + cols;
- res = 31 * res + (getFunc != null ? getFunc.hashCode() : 0);
- res = 31 * res + (setFunc != null ? setFunc.hashCode() : 0);
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java
deleted file mode 100644
index 2e1fc12..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.MatrixStorage;
-
-/**
- * {@link MatrixStorage} implementation that delegates to parent matrix.
- */
-public class MatrixDelegateStorage implements MatrixStorage {
- /** Parent matrix storage. */
- private MatrixStorage sto;
-
- /** Row offset in the parent matrix. */
- private int rowOff;
- /** Column offset in the parent matrix. */
- private int colOff;
-
- /** Amount of rows in the matrix. */
- private int rows;
- /** Amount of columns in the matrix. */
- private int cols;
-
- /**
- *
- */
- public MatrixDelegateStorage() {
- // No-op.
- }
-
- /**
- * @param sto Backing parent storage.
- * @param rowOff Row offset to parent matrix.
- * @param colOff Column offset to parent matrix.
- * @param rows Amount of rows in the view.
- * @param cols Amount of columns in the view.
- */
- public MatrixDelegateStorage(MatrixStorage sto, int rowOff, int colOff, int rows, int cols) {
- assert sto != null;
- assert rowOff >= 0;
- assert colOff >= 0;
- assert rows > 0;
- assert cols > 0;
-
- this.sto = sto;
-
- this.rowOff = rowOff;
- this.colOff = colOff;
-
- this.rows = rows;
- this.cols = cols;
- }
-
- /**
- *
- */
- public MatrixStorage delegate() {
- return sto;
- }
-
- /**
- *
- */
- public int rowOffset() {
- return rowOff;
- }
-
- /**
- *
- */
- public int columnOffset() {
- return colOff;
- }
-
- /**
- *
- */
- public int rowsLength() {
- return rows;
- }
-
- /**
- *
- */
- public int columnsLength() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return sto.get(rowOff + x, colOff + y);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- sto.set(rowOff + x, colOff + y, v);
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return sto.isArrayBased() && rowOff == 0 && colOff == 0;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return sto.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return sto.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return sto.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return sto.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public double[][] data() {
- return sto.data();
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(sto);
-
- out.writeInt(rowOff);
- out.writeInt(colOff);
-
- out.writeInt(rows);
- out.writeInt(cols);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- sto = (MatrixStorage)in.readObject();
-
- rowOff = in.readInt();
- colOff = in.readInt();
-
- rows = in.readInt();
- cols = in.readInt();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + rows;
- res = res * 37 + cols;
- res = res * 37 + rowOff;
- res = res * 37 + colOff;
- res = res * 37 + sto.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- MatrixDelegateStorage that = (MatrixDelegateStorage)o;
-
- return rows == that.rows && cols == that.cols && rowOff == that.rowOff && colOff == that.colOff &&
- (sto != null ? sto.equals(that.sto) : that.sto == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java
deleted file mode 100644
index 32c8624..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import org.apache.ignite.math.MatrixStorage;
-
-/**
- * Pivoted (index mapped) view over another matrix storage implementation.
- */
-public class PivotedMatrixStorage implements MatrixStorage {
- /** Matrix storage. */
- private MatrixStorage sto;
-
- /** */
- private int[] rowPivot;
- /** */
- private int[] colPivot;
- /** */
- private int[] rowUnpivot;
- /** */
- private int[] colUnpivot;
-
- /**
- *
- */
- public PivotedMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param sto Matrix storage.
- * @param rowPivot Pivot array for rows.
- * @param colPivot Pivot array for columns.
- */
- public PivotedMatrixStorage(MatrixStorage sto, int[] rowPivot, int[] colPivot) {
- assert sto != null;
- assert rowPivot != null;
- assert colPivot != null;
-
- this.sto = sto;
- this.rowPivot = rowPivot;
- this.colPivot = colPivot;
-
- rowUnpivot = invert(rowPivot);
- colUnpivot = invert(colPivot);
- }
-
- /**
- *
- */
- public int[] rowPivot() {
- return rowPivot;
- }
-
- /**
- *
- */
- public int[] columnPivot() {
- return colPivot;
- }
-
- /**
- *
- */
- public int[] rowUnpivot() {
- return rowUnpivot;
- }
-
- /**
- *
- */
- public int[] columnUnpivot() {
- return colUnpivot;
- }
-
- /**
- * @param sto Matrix storage.
- * @param pivot Pivot array.
- */
- public PivotedMatrixStorage(MatrixStorage sto, int[] pivot) {
- this(sto, pivot, pivot == null ? null : java.util.Arrays.copyOf(pivot, pivot.length));
- }
-
- /**
- * @param sto Matrix storage.
- */
- public PivotedMatrixStorage(MatrixStorage sto) {
- this(sto, sto == null ? null : identityPivot(sto.rowSize()), sto == null ? null : identityPivot(sto.columnSize()));
- }
-
- /**
- * @param i First row index to swap.
- * @param j Second row index to swap.
- */
- public void swapRows(int i, int j) {
- if (i != j) {
- int tmp = rowPivot[i];
-
- rowPivot[i] = rowPivot[j];
- rowPivot[j] = tmp;
-
- rowUnpivot[rowPivot[i]] = i;
- rowUnpivot[rowPivot[j]] = j;
- }
- }
-
- /**
- * @param i First column index to swap.
- * @param j Second column index to swap.
- */
- public void swapColumns(int i, int j) {
- if (i != j) {
- int tmp = colPivot[i];
-
- colPivot[i] = colPivot[j];
- colPivot[j] = tmp;
-
- colUnpivot[colPivot[i]] = i;
- colUnpivot[colPivot[j]] = j;
- }
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- return sto.get(rowPivot[x], colPivot[y]);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- sto.set(rowPivot[x], colPivot[y], v);
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return sto.columnSize();
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return sto.rowSize();
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(sto);
- out.writeObject(rowPivot);
- out.writeObject(colPivot);
- out.writeObject(rowUnpivot);
- out.writeObject(colUnpivot);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- sto = (MatrixStorage)in.readObject();
- rowPivot = (int[])in.readObject();
- colPivot = (int[])in.readObject();
- rowUnpivot = (int[])in.readObject();
- colUnpivot = (int[])in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return sto.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return sto.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return sto.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return sto.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + sto.hashCode();
- res = res * 37 + Arrays.hashCode(rowPivot);
- res = res * 37 + Arrays.hashCode(rowUnpivot);
- res = res * 37 + Arrays.hashCode(colPivot);
- res = res * 37 + Arrays.hashCode(colUnpivot);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- PivotedMatrixStorage that = (PivotedMatrixStorage)obj;
-
- return Arrays.equals(rowPivot, that.rowPivot) && Arrays.equals(rowUnpivot, that.rowUnpivot)
- && Arrays.equals(colPivot, that.colPivot) && Arrays.equals(colUnpivot, that.colUnpivot)
- && (sto != null ? sto.equals(that.sto) : that.sto == null);
- }
-
- /**
- * @param n Pivot array length.
- */
- private static int[] identityPivot(int n) {
- int[] pivot = new int[n];
-
- for (int i = 0; i < n; i++)
- pivot[i] = i;
-
- return pivot;
- }
-
- /**
- * @param pivot Pivot array to be inverted.
- */
- private static int[] invert(int[] pivot) {
- int[] x = new int[pivot.length];
-
- for (int i = 0; i < pivot.length; i++)
- x[pivot[i]] = i;
-
- return x;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java
deleted file mode 100644
index 8283201..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.nio.ByteBuffer;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.MurmurHash;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-
-/**
- * {@link MatrixStorage} implementation with random values in the matrix elements.
- */
-public class RandomMatrixStorage implements MatrixStorage {
- /** */
- private static final int PRIME1 = 104047;
- /** */
- private static final int PRIME2 = 101377;
- /** */
- private static final int PRIME3 = 64661;
- /** */
- private static final long SCALE = 1L << 32;
-
- /** Random generation seed. */
- private int seed;
-
- /** Amount of rows in the matrix. */
- private int rows;
- /** Amount of columns in the matrix. */
- private int cols;
-
- /** Whether fast hash is used, in {@link #get(int, int)}. */
- private boolean fastHash;
-
- /**
- * For externalization.
- */
- public RandomMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param fastHash Whether fast hash is used.
- */
- public RandomMatrixStorage(int rows, int cols, boolean fastHash) {
- assert rows > 0;
- assert cols > 0;
-
- this.rows = rows;
- this.cols = cols;
- this.fastHash = fastHash;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- if (!fastHash) {
- ByteBuffer buf = ByteBuffer.allocate(8);
-
- buf.putInt(x);
- buf.putInt(y);
- buf.flip();
-
- return (MurmurHash.hash64A(buf, seed) & (SCALE - 1)) / (double)SCALE;
- }
- else
- // This isn't a fantastic random number generator, but it is just fine for random projections.
- return ((((x * PRIME1) + y * PRIME2 + x * y * PRIME3) & 8) * 0.25) - 1;
- }
-
- /**
- *
- */
- public boolean isFastHash() {
- return fastHash;
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- throw new UnsupportedOperationException("Random matrix storage is a read-only storage.");
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
- out.writeInt(seed);
- out.writeBoolean(fastHash);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
- seed = in.readInt();
- fastHash = in.readBoolean();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + Boolean.hashCode(fastHash);
- res = res * 37 + seed;
- res = res * 37 + cols;
- res = res * 37 + rows;
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- RandomMatrixStorage that = (RandomMatrixStorage)o;
-
- return rows == that.rows && cols == that.cols && seed == that.seed && fastHash == that.fastHash;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java
deleted file mode 100644
index 82807c5..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java
+++ /dev/null
@@ -1,281 +0,0 @@
-// @java.file.header
-
-/* _________ _____ __________________ _____
- * __ ____/___________(_)______ /__ ____/______ ____(_)_______
- * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
- * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
- * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
- */
-
-package org.apache.ignite.math.impls.storage.matrix;
-
-import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
-import it.unimi.dsi.fastutil.ints.Int2DoubleRBTreeMap;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Map;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.Ignition;
-import org.apache.ignite.cache.CacheAtomicityMode;
-import org.apache.ignite.cache.CacheMode;
-import org.apache.ignite.cache.CachePeekMode;
-import org.apache.ignite.cache.CacheWriteSynchronizationMode;
-import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.lang.IgniteUuid;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.impls.CacheUtils;
-
-/**
- * {@link MatrixStorage} implementation for {@link org.apache.ignite.math.impls.matrix.SparseDistributedMatrix}.
- */
-public class SparseDistributedMatrixStorage extends CacheUtils implements MatrixStorage, StorageConstants {
- /** Amount of rows in the matrix. */
- private int rows;
- /** Amount of columns in the matrix. */
- private int cols;
-
- /** Row or column based storage mode. */
- private int stoMode;
- /** Random or sequential access mode. */
- private int acsMode;
-
- /** Actual distributed storage. */
- private IgniteCache<
- Integer /* Row or column index. */,
- Map<Integer, Double> /* Map-based row or column. */
- > cache = null;
-
- /**
- *
- */
- public SparseDistributedMatrixStorage() {
- // No-op.
- }
-
- /**
- * @param rows Amount of rows in the matrix.
- * @param cols Amount of columns in the matrix.
- * @param stoMode Row or column based storage mode.
- * @param acsMode Random or sequential access mode.
- */
- public SparseDistributedMatrixStorage(int rows, int cols, int stoMode, int acsMode) {
- assert rows > 0;
- assert cols > 0;
- assertAccessMode(acsMode);
- assertStorageMode(stoMode);
-
- this.rows = rows;
- this.cols = cols;
- this.stoMode = stoMode;
- this.acsMode = acsMode;
-
- cache = newCache();
- }
-
- /**
- *
- *
- */
- private IgniteCache<Integer, Map<Integer, Double>> newCache() {
- CacheConfiguration<Integer, Map<Integer, Double>> cfg = new CacheConfiguration<>();
-
- // Assume 10% density.
- cfg.setStartSize(Math.max(1024, (rows * cols) / 10));
-
- // Write to primary.
- cfg.setWriteSynchronizationMode(CacheWriteSynchronizationMode.PRIMARY_SYNC);
-
- // Atomic transactions only.
- cfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
-
- // No eviction.
- cfg.setEvictionPolicy(null);
-
- // No copying of values.
- cfg.setCopyOnRead(false);
-
- // Cache is partitioned.
- cfg.setCacheMode(CacheMode.PARTITIONED);
-
- // Random cache name.
- cfg.setName(new IgniteUuid().shortString());
-
- return Ignition.localIgnite().getOrCreateCache(cfg);
- }
-
- /**
- *
- *
- */
- public IgniteCache<Integer, Map<Integer, Double>> cache() {
- return cache;
- }
-
- /**
- *
- *
- */
- public int accessMode() {
- return acsMode;
- }
-
- /**
- *
- *
- */
- public int storageMode() {
- return stoMode;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- if (stoMode == ROW_STORAGE_MODE)
- return matrixGet(cache.getName(), x, y);
- else
- return matrixGet(cache.getName(), y, x);
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- if (stoMode == ROW_STORAGE_MODE)
- matrixSet(cache.getName(), x, y, v);
- else
- matrixSet(cache.getName(), y, x, v);
- }
-
- /**
- * Distributed matrix get.
- *
- * @param cacheName Matrix's cache.
- * @param a Row or column index.
- * @param b Row or column index.
- * @return Matrix value at (a, b) index.
- */
- private double matrixGet(String cacheName, int a, int b) {
- // Remote get from the primary node (where given row or column is stored locally).
- return ignite().compute(groupForKey(cacheName, a)).call(() -> {
- IgniteCache<Integer, Map<Integer, Double>> cache = Ignition.localIgnite().getOrCreateCache(cacheName);
-
- // Local get.
- Map<Integer, Double> map = cache.localPeek(a, CachePeekMode.PRIMARY);
-
- return (map == null || !map.containsKey(b)) ? 0.0 : map.get(b);
- });
- }
-
- /**
- * Distributed matrix set.
- *
- * @param cacheName Matrix's cache.
- * @param a Row or column index.
- * @param b Row or column index.
- * @param v New value to set.
- */
- private void matrixSet(String cacheName, int a, int b, double v) {
- // Remote set on the primary node (where given row or column is stored locally).
- ignite().compute(groupForKey(cacheName, a)).run(() -> {
- IgniteCache<Integer, Map<Integer, Double>> cache = Ignition.localIgnite().getOrCreateCache(cacheName);
-
- // Local get.
- Map<Integer, Double> map = cache.localPeek(a, CachePeekMode.PRIMARY);
-
- if (map == null)
- map = acsMode == SEQUENTIAL_ACCESS_MODE ? new Int2DoubleRBTreeMap() : new Int2DoubleOpenHashMap();
-
- if (v != 0.0)
- map.put(b, v);
- else if (map.containsKey(b))
- map.remove(b);
-
- // Local put.
- cache.put(a, map);
- });
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
- out.writeInt(acsMode);
- out.writeInt(stoMode);
- out.writeUTF(cache.getName());
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
- acsMode = in.readInt();
- stoMode = in.readInt();
- cache = ignite().getOrCreateCache(in.readUTF());
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return acsMode == SEQUENTIAL_ACCESS_MODE;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return acsMode == RANDOM_ACCESS_MODE;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** Destroy underlying cache. */
- @Override public void destroy() {
- cache.destroy();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + cols;
- res = res * 37 + rows;
- res = res * 37 + acsMode;
- res = res * 37 + stoMode;
- res = res * 37 + cache.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- SparseDistributedMatrixStorage that = (SparseDistributedMatrixStorage)obj;
-
- return rows == that.rows && cols == that.cols && acsMode == that.acsMode && stoMode == that.stoMode
- && (cache != null ? cache.equals(that.cache) : that.cache == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java
deleted file mode 100644
index e72da70..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * 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.storage.matrix;
-
-import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
-import it.unimi.dsi.fastutil.ints.Int2DoubleRBTreeMap;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.HashMap;
-import java.util.Map;
-import org.apache.ignite.math.MatrixStorage;
-import org.apache.ignite.math.StorageConstants;
-
-/**
- * Storage for sparse, local, on-heap matrix.
- */
-public class SparseLocalOnHeapMatrixStorage implements MatrixStorage, StorageConstants {
- /** Default zero value. */
- private static final double DEFAULT_VALUE = 0.0;
-
- /** */ private int rows;
- /** */ private int cols;
-
- /** */ private int acsMode;
- /** */ private int stoMode;
-
- /** Actual map storage. */
- private Map<Integer, Map<Integer, Double>> sto;
-
- /** */
- public SparseLocalOnHeapMatrixStorage() {
- // No-op.
- }
-
- /** */
- public SparseLocalOnHeapMatrixStorage(int rows, int cols, int acsMode, int stoMode) {
- assert rows > 0;
- assert cols > 0;
- assertAccessMode(acsMode);
- assertStorageMode(stoMode);
-
- this.rows = rows;
- this.cols = cols;
- this.acsMode = acsMode;
- this.stoMode = stoMode;
-
- sto = new HashMap<>();
- }
-
- /**
- *
- *
- */
- public int getStorageMode() {
- return stoMode;
- }
-
- /**
- *
- *
- */
- public int getAccessMode() {
- return acsMode;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int x, int y) {
- if (stoMode == ROW_STORAGE_MODE) {
- Map<Integer, Double> row = sto.get(x);
-
- if (row != null) {
- Double val = row.get(y);
-
- if (val != null)
- return val;
- }
-
- return DEFAULT_VALUE;
- }
- else {
- Map<Integer, Double> col = sto.get(y);
-
- if (col != null) {
- Double val = col.get(x);
-
- if (val != null)
- return val;
- }
-
- return DEFAULT_VALUE;
- }
- }
-
- /** {@inheritDoc} */
- @Override public void set(int x, int y, double v) {
- // Ignore default values (currently 0.0).
- if (v != DEFAULT_VALUE) {
- if (stoMode == ROW_STORAGE_MODE) {
- Map<Integer, Double> row = sto.computeIfAbsent(x, k ->
- acsMode == SEQUENTIAL_ACCESS_MODE ? new Int2DoubleRBTreeMap() : new Int2DoubleOpenHashMap());
-
- row.put(y, v);
- }
- else {
- Map<Integer, Double> col = sto.computeIfAbsent(y, k ->
- acsMode == SEQUENTIAL_ACCESS_MODE ? new Int2DoubleRBTreeMap() : new Int2DoubleOpenHashMap());
-
- col.put(x, v);
- }
- }
- else {
- if (stoMode == ROW_STORAGE_MODE) {
- if (sto.containsKey(x)) {
- Map<Integer, Double> row = sto.get(x);
-
- if (row.containsKey(y))
- row.remove(y);
- }
-
- }
- else {
- if (sto.containsKey(y)) {
- Map<Integer, Double> col = sto.get(y);
-
- if (col.containsKey(x))
- col.remove(x);
- }
- }
- }
- }
-
- /** {@inheritDoc} */
- @Override public int columnSize() {
- return cols;
- }
-
- /** {@inheritDoc} */
- @Override public int rowSize() {
- return rows;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeInt(rows);
- out.writeInt(cols);
- out.writeInt(acsMode);
- out.writeInt(stoMode);
- out.writeObject(sto);
- }
-
- /** {@inheritDoc} */
- @SuppressWarnings({"unchecked"})
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- rows = in.readInt();
- cols = in.readInt();
- acsMode = in.readInt();
- stoMode = in.readInt();
- sto = (Map<Integer, Map<Integer, Double>>)in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return acsMode == SEQUENTIAL_ACCESS_MODE;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return acsMode == RANDOM_ACCESS_MODE;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + rows;
- res = res * 37 + cols;
- res = res * 37 + sto.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- SparseLocalOnHeapMatrixStorage that = (SparseLocalOnHeapMatrixStorage)o;
-
- return rows == that.rows && cols == that.cols && acsMode == that.acsMode && stoMode == that.stoMode
- && (sto != null ? sto.equals(that.sto) : that.sto == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java
deleted file mode 100644
index aba47db..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 specific implementations for matrix storage models.
- */
-package org.apache.ignite.math.impls.storage.matrix;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java
deleted file mode 100644
index ef59c62..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * 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.storage.vector;
-
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * Array based {@link VectorStorage} implementation.
- */
-public class ArrayVectorStorage implements VectorStorage {
- /** Backing data array. */
- private double[] data;
-
- /**
- * IMPL NOTE required by {@link Externalizable}.
- */
- public ArrayVectorStorage() {
- // No-op.
- }
-
- /**
- * @param size Vector size.
- */
- public ArrayVectorStorage(int size) {
- assert size > 0;
-
- data = new double[size];
- }
-
- /**
- * @param data Backing data array.
- */
- public ArrayVectorStorage(double[] data) {
- assert data != null;
-
- this.data = data;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return data == null ? 0 : data.length;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return data[i];
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- data[i] = v;
- }
-
- /** {@inheritDoc}} */
- @Override public boolean isArrayBased() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public double[] data() {
- return data;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(data);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- data = (double[])in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + Arrays.hashCode(data);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- ArrayVectorStorage that = (ArrayVectorStorage)obj;
-
- return Arrays.equals(data, (that.data));
- }
-}
[02/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java
new file mode 100644
index 0000000..b7e390e
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/MatrixVectorViewTest.java
@@ -0,0 +1,209 @@
+package org.apache.ignite.math.impls.vector;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.IndexException;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests for {@link MatrixVectorView}.
+ */
+public class MatrixVectorViewTest {
+ /** */
+ private static final String UNEXPECTED_VALUE = "Unexpected value";
+ /** */
+ private static final int SMALL_SIZE = 3;
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ private Matrix parent;
+
+ /** */
+ @Before
+ public void setup() {
+ parent = newMatrix(SMALL_SIZE, SMALL_SIZE);
+ }
+
+ /** */
+ @Test
+ public void testDiagonal() {
+ Vector vector = parent.viewDiagonal();
+
+ for (int i = 0; i < SMALL_SIZE; i++)
+ assertView(i, i, vector, i);
+ }
+
+ /** */
+ @Test
+ public void testRow() {
+ for (int i = 0; i < SMALL_SIZE; i++) {
+ Vector viewRow = parent.viewRow(i);
+
+ for (int j = 0; j < SMALL_SIZE; j++)
+ assertView(i, j, viewRow, j);
+ }
+ }
+
+ /** */
+ @Test
+ public void testCols() {
+ for (int i = 0; i < SMALL_SIZE; i++) {
+ Vector viewCol = parent.viewColumn(i);
+
+ for (int j = 0; j < SMALL_SIZE; j++)
+ assertView(j, i, viewCol, j);
+ }
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ for (int rowSize : new int[] {1, 2, 3, 4})
+ for (int colSize : new int[] {1, 2, 3, 4})
+ for (int row = 0; row < rowSize; row++)
+ for (int col = 0; col < colSize; col++)
+ for (int rowStride = 0; rowStride < rowSize; rowStride++)
+ for (int colStride = 0; colStride < colSize; colStride++)
+ if (rowStride != 0 || colStride != 0)
+ assertMatrixVectorView(newMatrix(rowSize, colSize), row, col, rowStride, colStride);
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void parentNullTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(null, 1, 1, 1, 1).size());
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void rowNegativeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, -1, 1, 1, 1).size());
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void colNegativeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, -1, 1, 1).size());
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void rowTooLargeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, parent.rowSize() + 1, 1, 1, 1).size());
+ }
+
+ /** */
+ @Test(expected = IndexException.class)
+ public void colTooLargeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, parent.columnSize() + 1, 1, 1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void rowStrideNegativeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, 1, -1, 1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void colStrideNegativeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, 1, 1, -1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void rowStrideTooLargeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, 1, parent.rowSize() + 1, 1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void colStrideTooLargeTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, 1, 1, parent.columnSize() + 1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void bothStridesZeroTest() {
+ //noinspection ConstantConditions
+ assertEquals(IMPOSSIBLE_SIZE,
+ new MatrixVectorView(parent, 1, 1, 0, 0).size());
+ }
+
+ /** */
+ private void assertMatrixVectorView(Matrix parent, int row, int col, int rowStride, int colStride) {
+ MatrixVectorView view = new MatrixVectorView(parent, row, col, rowStride, colStride);
+
+ String desc = "parent [" + parent.rowSize() + "x" + parent.columnSize() + "], view ["
+ + row + "x" + col + "], strides [" + rowStride + ", " + colStride + "]";
+
+ final int size = view.size();
+
+ final int sizeByRows = rowStride == 0 ? IMPOSSIBLE_SIZE : (parent.rowSize() - row) / rowStride;
+ final int sizeByCols = colStride == 0 ? IMPOSSIBLE_SIZE : (parent.columnSize() - col) / colStride;
+
+ assertTrue("Size " + size + " differs from expected for " + desc,
+ size == sizeByRows || size == sizeByCols);
+
+ for (int idx = 0; idx < size; idx++) {
+ final int rowIdx = row + idx * rowStride;
+ final int colIdx = col + idx * colStride;
+
+ assertEquals(UNEXPECTED_VALUE + " at view index " + idx + desc,
+ parent.get(rowIdx, colIdx), view.get(idx), 0d);
+ }
+ }
+
+ /** */
+ private Matrix newMatrix(int rowSize, int colSize) {
+ Matrix res = new DenseLocalOnHeapMatrix(rowSize, colSize);
+
+ for (int i = 0; i < res.rowSize(); i++)
+ for (int j = 0; j < res.columnSize(); j++)
+ res.set(i, j, i * res.rowSize() + j);
+
+ return res;
+ }
+
+ /** */
+ private void assertView(int row, int col, Vector view, int viewIdx) {
+ assertValue(row, col, view, viewIdx);
+
+ parent.set(row, col, parent.get(row, col) + 1);
+
+ assertValue(row, col, view, viewIdx);
+
+ view.set(viewIdx, view.get(viewIdx) + 2);
+
+ assertValue(row, col, view, viewIdx);
+ }
+
+ /** */
+ private void assertValue(int row, int col, Vector view, int viewIdx) {
+ assertEquals(UNEXPECTED_VALUE + " at row " + row + " col " + col, parent.get(row, col), view.get(viewIdx), 0d);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java
new file mode 100644
index 0000000..91650dc
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/PivotedVectorViewConstructorTest.java
@@ -0,0 +1,211 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.CardinalityException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class PivotedVectorViewConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ private static final SampleParams sampleParams = new SampleParams();
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void nullVecParamTest() {
+ assertEquals("Expect exception due to null vector param.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(null, sampleParams.pivot).size());
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void nullVecParam2Test() {
+ assertEquals("Expect exception due to null vector param, with unpivot.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(null, sampleParams.pivot, sampleParams.unpivot).size());
+ }
+
+ /** */
+ @Test(expected = NullPointerException.class)
+ public void nullPivotParamTest() {
+ assertEquals("Expect exception due to null pivot param.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, null).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullPivotParam2Test() {
+ assertEquals("Expect exception due to null pivot param, with unpivot.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, null, sampleParams.unpivot).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullUnpivotParam2Test() {
+ assertEquals("Expect exception due to null unpivot param.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, sampleParams.pivot, null).size());
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void emptyPivotTest() {
+ assertEquals("Expect exception due to empty pivot param.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, new int[] {}).size());
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void emptyPivot2Test() {
+ assertEquals("Expect exception due to empty pivot param, with unpivot.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, new int[] {}, sampleParams.unpivot).size());
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void wrongPivotTest() {
+ assertEquals("Expect exception due to wrong pivot param.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, new int[] {0}).size());
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void wrongPivot2Test() {
+ assertEquals("Expect exception due to wrong pivot param, with unpivot.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, new int[] {0}, sampleParams.unpivot).size());
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void emptyUnpivotTest() {
+ assertEquals("Expect exception due to empty unpivot param.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, sampleParams.pivot, new int[] {}).size());
+ }
+
+ /** */
+ @Test(expected = CardinalityException.class)
+ public void wrongUnpivotTest() {
+ assertEquals("Expect exception due to wrong unpivot param, with unpivot.", IMPOSSIBLE_SIZE,
+ new PivotedVectorView(sampleParams.vec, sampleParams.pivot, new int[] {0}).size());
+ }
+
+ /** */
+ @Test
+ public void basicPivotTest() {
+ final PivotedVectorView pvv = new PivotedVectorView(sampleParams.vec, sampleParams.pivot);
+
+ final int size = sampleParams.vec.size();
+
+ assertEquals("View size differs from expected.", size, pvv.size());
+
+ assertSame("Base vector differs from expected.", sampleParams.vec, pvv.getBaseVector());
+
+ for (int idx = 0; idx < size; idx++) {
+ assertEquals("Sample pivot and unpivot differ from expected",
+ idx, sampleParams.unpivot[sampleParams.pivot[idx]]);
+
+ assertEquals("Pivot differs from expected at index " + idx,
+ sampleParams.pivot[idx], pvv.pivot(idx));
+
+ assertEquals("Default unpivot differs from expected at index " + idx,
+ sampleParams.unpivot[idx], pvv.unpivot(idx));
+
+ final Metric metric = new Metric(sampleParams.vec.get(idx), pvv.get(pvv.pivot(idx)));
+
+ assertTrue("Not close enough at index " + idx + ", " + metric, metric.closeEnough());
+ }
+
+ for (int idx = 0; idx < size; idx++) {
+ sampleParams.vec.set(idx, sampleParams.vec.get(idx) + idx + 1);
+
+ final Metric metric = new Metric(sampleParams.vec.get(idx), pvv.get(pvv.pivot(idx)));
+
+ assertTrue("Modified value not close enough at index " + idx + ", " + metric, metric.closeEnough());
+ }
+ }
+
+ /** */
+ @Test
+ public void basicUnpivotTest() {
+ final PivotedVectorView pvv = new PivotedVectorView(sampleParams.vec, sampleParams.pivot, sampleParams.unpivot);
+
+ final int size = sampleParams.vec.size();
+
+ assertEquals("View size differs from expected.", size, pvv.size());
+
+ for (int idx = 0; idx < size; idx++) {
+ assertEquals("Unpivot differs from expected at index " + idx,
+ sampleParams.unpivot[idx], pvv.unpivot(idx));
+
+ final Metric metric = new Metric(sampleParams.vec.get(idx), pvv.get(pvv.unpivot(idx)));
+
+ assertTrue("Not close enough at index " + idx + ", " + metric, metric.closeEnough());
+ }
+ }
+
+ /** */
+ private static class SampleParams {
+ /** */
+ final double[] data = new double[] {0, 1};
+ /** */
+ final Vector vec = new DenseLocalOnHeapVector(data);
+ /** */
+ final int[] pivot = new int[] {1, 0};
+ /** */
+ final int[] unpivot = new int[] {1, 0};
+ }
+
+ /** */
+ private static class Metric { // todo consider if softer tolerance (like say 0.1 or 0.01) would make sense here
+ /** */
+ private final double exp;
+
+ /** */
+ private final double obtained;
+
+ /** **/
+ Metric(double exp, double obtained) {
+ this.exp = exp;
+ this.obtained = obtained;
+ }
+
+ /** */
+ boolean closeEnough() {
+ return new Double(exp).equals(obtained) || closeEnoughToZero();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ return "Metric{" + "expected=" + exp +
+ ", obtained=" + obtained +
+ '}';
+ }
+
+ /** */
+ private boolean closeEnoughToZero() {
+ return (new Double(exp).equals(0.0) && new Double(obtained).equals(-0.0))
+ || (new Double(exp).equals(-0.0) && new Double(obtained).equals(0.0));
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java
new file mode 100644
index 0000000..6d4e4f1
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/RandomVectorConstructorTest.java
@@ -0,0 +1,145 @@
+/*
+ * 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.vector;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class RandomVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = org.apache.ignite.math.exceptions.UnsupportedOperationException.class)
+ public void mapInvalidArgsTest() {
+ assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
+ new RandomVector(new HashMap<String, Object>() {{
+ put("invalid", 99);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void mapMissingArgsTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("paramMissing", "whatever");
+ }};
+
+ assertEquals("Expect exception due to missing args.",
+ -1, new RandomVector(test).size());
+ }
+
+ /** */
+ @Test(expected = ClassCastException.class)
+ public void mapInvalidParamTypeTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("size", "whatever");
+ put("fastHash", true);
+ }};
+
+ assertEquals("Expect exception due to invalid param type.", IMPOSSIBLE_SIZE,
+ new RandomVector(test).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void mapNullTest() {
+ //noinspection ConstantConditions
+ assertEquals("Null map args.", IMPOSSIBLE_SIZE,
+ new RandomVector(null).size());
+ }
+
+ /** */
+ @Test
+ public void mapTest() {
+ assertEquals("Size from args.", 99,
+ new RandomVector(new HashMap<String, Object>() {{
+ put("size", 99);
+ }}).size());
+
+ final int test = 99;
+
+ assertEquals("Size from args with fastHash false.", test,
+ new RandomVector(new HashMap<String, Object>() {{
+ put("size", test);
+ put("fastHash", false);
+ }}).size());
+
+ assertEquals("Size from args with fastHash true.", test,
+ new RandomVector(new HashMap<String, Object>() {{
+ put("size", test);
+ put("fastHash", true);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new RandomVector(-1).size());
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ final int basicSize = 3;
+
+ Vector v1 = new RandomVector(basicSize);
+
+ //noinspection EqualsWithItself
+ assertTrue("Expect vector to be equal to self", v1.equals(v1));
+
+ //noinspection ObjectEqualsNull
+ assertFalse("Expect vector to be not equal to null", v1.equals(null));
+
+ assertEquals("Size differs from expected", basicSize, v1.size());
+
+ verifyValues(v1);
+
+ Vector v2 = new RandomVector(basicSize, true);
+
+ assertEquals("Size differs from expected", basicSize, v2.size());
+
+ verifyValues(v2);
+
+ Vector v3 = new RandomVector(basicSize, false);
+
+ assertEquals("Size differs from expected", basicSize, v3.size());
+
+ verifyValues(v3);
+ }
+
+ /** */
+ private void verifyValues(Vector v) {
+ for (Vector.Element e : v.all()) {
+ double val = e.get();
+
+ assertTrue("Value too small: " + val + " at index " + e.index(), -1d <= val);
+
+ assertTrue("Value too large: " + val + " at index " + e.index(), val <= 1d);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java
new file mode 100644
index 0000000..69e22e0
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorConstructorTest.java
@@ -0,0 +1,159 @@
+/*
+ * 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.vector;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class SingleElementVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void mapInvalidArgsTest() {
+ assertEquals("Expect exception due to invalid args.", IMPOSSIBLE_SIZE,
+ new SingleElementVector(new HashMap<String, Object>() {{
+ put("invalid", 99);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = UnsupportedOperationException.class)
+ public void mapMissingArgsTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("size", 1);
+
+ put("paramMissing", "whatever");
+ }};
+
+ assertEquals("Expect exception due to missing args.",
+ -1, new SingleElementVector(test).size());
+ }
+
+ /** */
+ @Test(expected = ClassCastException.class)
+ public void mapInvalidParamTypeTest() {
+ final Map<String, Object> test = new HashMap<String, Object>() {{
+ put("size", "whatever");
+
+ put("index", 0);
+ put("value", 1.0);
+ }};
+
+ assertEquals("Expect exception due to invalid param type.", IMPOSSIBLE_SIZE,
+ new SingleElementVector(test).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void mapNullTest() {
+ //noinspection ConstantConditions
+ assertEquals("Null map args.", IMPOSSIBLE_SIZE,
+ new SingleElementVector(null).size());
+ }
+
+ /** */
+ @Test
+ public void mapTest() {
+ assertEquals("Size from array in args.", 99,
+ new SingleElementVector(new HashMap<String, Object>() {{
+ put("size", 99);
+ put("index", 0);
+ put("value", 1.0);
+ }}).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new SingleElementVector(-1, 0, 1.0).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void zeroSizeTest() {
+ assertEquals("Zero size.", IMPOSSIBLE_SIZE,
+ new SingleElementVector(0, 0, 1.0).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void wrongIndexTest() {
+ //noinspection ConstantConditions
+ assertEquals("Wrong index.", IMPOSSIBLE_SIZE,
+ new SingleElementVector(1, 2, 1.0).size());
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ final int[] sizes = new int[] {1, 4, 8};
+
+ for (int size : sizes)
+ for (int idx = 0; idx < size; idx++)
+ basicTest(size, idx);
+ }
+
+ /** */
+ private void basicTest(int size, int idx) {
+ final Double expVal = (double)(size - idx);
+
+ Vector v = new SingleElementVector(size, idx, expVal);
+
+ assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
+ expVal.equals(v.get(idx)));
+
+ final double delta = 1.0;
+
+ v.set(idx, expVal - delta);
+
+ assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
+ expVal.equals(v.get(idx) + delta));
+
+ final Double zero = 0.0;
+
+ for (int i = 0; i < size; i++) {
+ if (i == idx)
+ continue;
+
+ assertTrue("Expect zero at index " + i + " for size " + size,
+ zero.equals(v.get(i)));
+
+ boolean eCaught = false;
+
+ try {
+ v.set(i, 1.0);
+ }
+ catch (UnsupportedOperationException uoe) {
+ eCaught = true;
+ }
+
+ assertTrue("Expect " + java.lang.UnsupportedOperationException.class.getSimpleName()
+ + " at index " + i + " for size " + size, eCaught);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java
new file mode 100644
index 0000000..957f3b7
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SingleElementVectorViewConstructorTest.java
@@ -0,0 +1,137 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/** */
+public class SingleElementVectorViewConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ private static final SampleHelper helper = new SampleHelper();
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void nullVecParamTest() {
+ assertEquals("Expect exception due to null vector param.", IMPOSSIBLE_SIZE,
+ new SingleElementVectorView(null, helper.idx).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeIdxParamTest() {
+ assertEquals("Expect exception due to negative index param.", IMPOSSIBLE_SIZE,
+ new SingleElementVectorView(helper.vec, -1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void tooLargeIdxParamTest() {
+ assertEquals("Expect exception due to too large index param.", IMPOSSIBLE_SIZE,
+ new SingleElementVectorView(helper.vec, helper.vec.size()).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void emptyVecParamTest() {
+ assertEquals("Expect exception due to empty vector param.", IMPOSSIBLE_SIZE,
+ new SingleElementVectorView(helper.vecEmpty, 0).size());
+ }
+
+ /** */
+ @Test
+ public void basicTest() {
+ final int[] sizes = new int[] {1, 4, 8};
+
+ for (int size : sizes)
+ for (int idx = 0; idx < size; idx++)
+ basicTest(size, idx);
+ }
+
+ /** */
+ private void basicTest(int size, int idx) {
+ final Double expVal = (double)(size - idx);
+
+ Vector orig = helper.newSample(size, idx, expVal);
+
+ SingleElementVectorView svv = new SingleElementVectorView(orig, idx);
+
+ assertEquals("Size differs from expected", size, svv.size());
+
+ assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
+ expVal.equals(svv.get(idx)));
+
+ final double delta = 1.0;
+
+ svv.set(idx, expVal - delta);
+
+ assertTrue("Expect value " + expVal + " at index " + idx + " for size " + size,
+ expVal.equals(orig.get(idx) + delta));
+
+ final Double zero = 0.0;
+
+ for (int i = 0; i < size; i++) {
+ if (i == idx)
+ continue;
+
+ assertTrue("Expect zero at index " + i + " for size " + size,
+ zero.equals(svv.get(i)));
+
+ boolean eCaught = false;
+
+ try {
+ svv.set(i, 1.0);
+ }
+ catch (UnsupportedOperationException uoe) {
+ eCaught = true;
+ }
+
+ assertTrue("Expect " + UnsupportedOperationException.class.getSimpleName()
+ + " at index " + i + " for size " + size, eCaught);
+ }
+ }
+
+ /** */
+ private static class SampleHelper {
+ /** */
+ final double[] data = new double[] {0, 1};
+ /** */
+ final Vector vec = new DenseLocalOnHeapVector(data);
+ /** */
+ final Vector vecEmpty = new DenseLocalOnHeapVector(new double[] {});
+ /** */
+ final int idx = 0;
+
+ /** */
+ Vector newSample(int size, int idx, double expVal) {
+ final Vector v = new DenseLocalOnHeapVector(size);
+
+ for (int i = 0; i < size; i++)
+ v.set(i, i == idx ? expVal : i);
+
+ return v;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java
new file mode 100644
index 0000000..2be4a10
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/SparseLocalVectorConstructorTest.java
@@ -0,0 +1,54 @@
+/*
+ * 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.vector;
+
+import org.apache.ignite.math.StorageConstants;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class SparseLocalVectorConstructorTest {
+ /** */
+ private static final int IMPOSSIBLE_SIZE = -1;
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void negativeSizeTest() {
+ assertEquals("Negative size.", IMPOSSIBLE_SIZE,
+ new SparseLocalVector(-1, 1).size());
+ }
+
+ /** */
+ @Test(expected = AssertionError.class)
+ public void zeroSizeTest() {
+ assertEquals("0 size.", IMPOSSIBLE_SIZE,
+ new SparseLocalVector(0, 1).size());
+ }
+
+ /** */
+ @Test
+ public void primitiveTest() {
+ assertEquals("1 size, random access.", 1,
+ new SparseLocalVector(1, StorageConstants.RANDOM_ACCESS_MODE).size());
+
+ assertEquals("1 size, sequential access.", 1,
+ new SparseLocalVector(1, StorageConstants.SEQUENTIAL_ACCESS_MODE).size());
+
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java
new file mode 100644
index 0000000..992018a
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorAttributesTest.java
@@ -0,0 +1,217 @@
+/*
+ * 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.vector;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/** */
+public class VectorAttributesTest {
+ /** */
+ private final List<AttrCfg> attrCfgs = Arrays.asList(
+ new AttrCfg("isDense", Vector::isDense,
+ DenseLocalOnHeapVector.class, DenseLocalOffHeapVector.class, RandomVector.class, ConstantVector.class,
+ SingleElementVector.class),
+ new AttrCfg("isArrayBased", Vector::isArrayBased,
+ DenseLocalOnHeapVector.class),
+ new AttrCfg("isSequentialAccess", Vector::isSequentialAccess,
+ DenseLocalOnHeapVector.class, DenseLocalOffHeapVector.class, SparseLocalVectorSequentialAccess.class,
+ RandomVector.class, ConstantVector.class, SingleElementVector.class),
+ new AttrCfg("guidNotNull", v -> v.guid() == null), // IMPL NOTE this is somewhat artificial
+ new AttrCfg("isRandomAccess", Vector::isRandomAccess,
+ DenseLocalOnHeapVector.class, DenseLocalOffHeapVector.class, RandomVector.class, ConstantVector.class,
+ SingleElementVector.class, SparseLocalVectorSequentialAccess.class, SparseLocalVectorRandomAccess.class),
+ new AttrCfg("isDistributed", Vector::isDistributed));
+
+ /** */
+ private final List<Specification> specFixture = Arrays.asList(
+ new Specification(new DenseLocalOnHeapVector(1)),
+ new Specification(new DenseLocalOffHeapVector(1)),
+ new Specification(new DelegatingVector(new DenseLocalOnHeapVector(1)),
+ DenseLocalOnHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
+ "isRandomAccess", "isDistributed"),
+ new Specification(new DelegatingVector(new DenseLocalOffHeapVector(1)),
+ DenseLocalOffHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
+ "isRandomAccess", "isDistributed"),
+ new Specification(new SparseLocalVectorSequentialAccess(1)),
+ new Specification(new SparseLocalVectorRandomAccess(1)),
+ new Specification(new RandomVector(1)),
+ new Specification(new ConstantVector(1, 1.0)),
+ new Specification(new FunctionVector(1, idx -> (double)idx)),
+ new Specification(new SingleElementVector(1, 0, 1.0)),
+ new Specification(new PivotedVectorView(new DenseLocalOnHeapVector(1), new int[] {0}),
+ DenseLocalOnHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
+ "isRandomAccess", "isDistributed"),
+ new Specification(new PivotedVectorView(new DenseLocalOffHeapVector(1), new int[] {0}),
+ DenseLocalOffHeapVector.class, "isDense", "isArrayBased", "isSequentialAccess",
+ "isRandomAccess", "isDistributed"),
+ new Specification(new SingleElementVectorView(new DenseLocalOnHeapVector(1), 0),
+ DenseLocalOnHeapVector.class, "isDense", "isSequentialAccess",
+ "isRandomAccess", "isDistributed"),
+ new Specification(new SingleElementVectorView(new DenseLocalOffHeapVector(1), 0),
+ DenseLocalOffHeapVector.class, "isDense", "isSequentialAccess",
+ "isRandomAccess", "isDistributed"),
+ new Specification(new MatrixVectorView(new DenseLocalOnHeapMatrix(1, 1), 0, 0, 1, 1),
+ DenseLocalOnHeapVector.class, "isDense",
+ "isRandomAccess", "isDistributed"), // todo find out why "isSequentialAccess" fails here
+ new Specification(new MatrixVectorView(new DenseLocalOffHeapMatrix(1, 1), 0, 0, 1, 1),
+ DenseLocalOffHeapVector.class, "isDense",
+ "isRandomAccess", "isDistributed"));
+
+ /** */
+ @Test
+ public void isDenseTest() {
+ assertAttribute("isDense");
+ }
+
+ /** */
+ @Test
+ public void isArrayBasedTest() {
+ assertAttribute("isArrayBased");
+ }
+
+ /** */
+ @Test
+ public void isSequentialAccessTest() {
+ assertAttribute("isSequentialAccess");
+ }
+
+ /** */
+ @Test
+ public void guidTest() {
+ assertAttribute("guidNotNull");
+ }
+
+ /** */
+ @Test
+ public void isRandomAccessTest() {
+ assertAttribute("isRandomAccess");
+ }
+
+ /** */
+ @Test
+ public void isDistributedTest() {
+ assertAttribute("isDistributed");
+ }
+
+ /** */
+ private void assertAttribute(String name) {
+ final AttrCfg attr = attrCfg(name);
+
+ for (Specification spec : specFixture)
+ spec.verify(attr);
+ }
+
+ /** */
+ private AttrCfg attrCfg(String name) {
+ for (AttrCfg attr : attrCfgs)
+ if (attr.name.equals(name))
+ return attr;
+
+ throw new IllegalArgumentException("Undefined attribute " + name);
+ }
+
+ /** See http://en.wikipedia.org/wiki/Specification_pattern */
+ private static class Specification {
+ /** */
+ private final Vector v;
+ /** */
+ private final Class<? extends Vector> underlyingType;
+ /** */
+ private final List<String> attrsFromUnderlying;
+ /** */
+ final String desc;
+
+ /** */
+ Specification(Vector v, Class<? extends Vector> underlyingType, String... attrsFromUnderlying) {
+ this.v = v;
+ this.underlyingType = underlyingType;
+ this.attrsFromUnderlying = Arrays.asList(attrsFromUnderlying);
+ final Class<? extends Vector> clazz = v.getClass();
+ desc = clazz.getSimpleName() + (clazz.equals(underlyingType)
+ ? "" : " (underlying type " + underlyingType.getSimpleName() + ")");
+ }
+
+ /** */
+ Specification(Vector v) {
+ this(v, v.getClass());
+ }
+
+ /** */
+ void verify(AttrCfg attr) {
+ final boolean obtained = attr.obtain.apply(v);
+
+ final Class<? extends Vector> typeToCheck
+ = attrsFromUnderlying.contains(attr.name) ? underlyingType : v.getClass();
+
+ final boolean exp = attr.trueInTypes.contains(typeToCheck);
+
+ assertEquals("Unexpected " + attr.name + " value for " + desc, exp, obtained);
+ }
+ }
+
+ /** */
+ private static class AttrCfg {
+ /** */
+ final String name;
+ /** */
+ final Function<Vector, Boolean> obtain;
+ /** */
+ final List<Class> trueInTypes;
+
+ /** */
+ AttrCfg(String name, Function<Vector, Boolean> obtain, Class... trueInTypes) {
+ this.name = name;
+ this.obtain = obtain;
+ this.trueInTypes = Arrays.asList(trueInTypes);
+ }
+ }
+
+ /** */
+ private static class SparseLocalVectorSequentialAccess extends SparseLocalVector {
+ /** */
+ public SparseLocalVectorSequentialAccess() {
+ // No-op.
+ }
+
+ /** */
+ SparseLocalVectorSequentialAccess(int size) {
+ super(size, SEQUENTIAL_ACCESS_MODE);
+ }
+ }
+
+ /** */
+ private static class SparseLocalVectorRandomAccess extends SparseLocalVector {
+ /** */
+ public SparseLocalVectorRandomAccess() {
+ // No-op.
+ }
+
+ /** */
+ SparseLocalVectorRandomAccess(int size) {
+ super(size, RANDOM_ACCESS_MODE);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java
new file mode 100644
index 0000000..67eb8ba
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorFoldMapTest.java
@@ -0,0 +1,122 @@
+/*
+ * 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.vector;
+
+import java.util.Arrays;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.functions.Functions;
+import org.junit.Test;
+
+import static java.util.function.DoubleUnaryOperator.identity;
+import static org.junit.Assert.assertTrue;
+
+/** See also: {@link AbstractVectorTest} and {@link VectorToMatrixTest}. */
+public class VectorFoldMapTest {
+ /** */
+ @Test
+ public void mapVectorTest() {
+ operationVectorTest((operand1, operand2) -> operand1 + operand2, (Vector v1, Vector v2) -> v1.map(v2, Functions.PLUS));
+ }
+
+ /** */
+ @Test
+ public void mapDoubleFunctionTest() {
+ consumeSampleVectors((v, desc) -> operatorTest(v, desc,
+ (vec) -> vec.map(Functions.INV), (val) -> 1.0 / val));
+ }
+
+ /** */
+ @Test
+ public void mapBiFunctionTest() {
+ consumeSampleVectors((v, desc) -> operatorTest(v, desc,
+ (vec) -> vec.map(Functions.PLUS, 1.0), (val) -> 1.0 + val));
+ }
+
+ /** */
+ @Test
+ public void foldMapTest() {
+ toDoubleTest(
+ ref -> Arrays.stream(ref).map(identity()).sum(),
+ (v) -> v.foldMap(Functions.PLUS, Functions.IDENTITY, 0.0));
+ }
+
+ /** */
+ @Test
+ public void foldMapVectorTest() {
+ toDoubleTest(
+ ref -> 2.0 * Arrays.stream(ref).sum(),
+ (v) -> v.foldMap(v, Functions.PLUS, Functions.PLUS, 0.0));
+
+ }
+
+ /** */
+ private void operatorTest(Vector v, String desc, Function<Vector, Vector> op, Function<Double, Double> refOp) {
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ VectorImplementationsTest.ElementsChecker checker = new VectorImplementationsTest.ElementsChecker(v, ref, desc);
+
+ Vector actual = op.apply(v);
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = refOp.apply(ref[idx]);
+
+ checker.assertCloseEnough(actual, ref);
+ }
+
+ /** */
+ private void toDoubleTest(Function<double[], Double> calcRef, Function<Vector, Double> calcVec) {
+ consumeSampleVectors((v, desc) -> {
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ new VectorImplementationsTest.ElementsChecker(v, ref, desc); // IMPL NOTE this initialises vector and reference array
+
+ final VectorImplementationsTest.Metric metric = new VectorImplementationsTest.Metric(calcRef.apply(ref), calcVec.apply(v));
+
+ assertTrue("Not close enough at " + desc
+ + ", " + metric, metric.closeEnough());
+ });
+ }
+
+ /** */
+ private void operationVectorTest(BiFunction<Double, Double, Double> operation,
+ BiFunction<Vector, Vector, Vector> vecOperation) {
+ consumeSampleVectors((v, desc) -> {
+ // TODO find out if more elaborate testing scenario is needed or it's okay as is.
+ final int size = v.size();
+ final double[] ref = new double[size];
+
+ final VectorImplementationsTest.ElementsChecker checker = new VectorImplementationsTest.ElementsChecker(v, ref, desc);
+ final Vector operand = v.copy();
+
+ for (int idx = 0; idx < size; idx++)
+ ref[idx] = operation.apply(ref[idx], ref[idx]);
+
+ checker.assertCloseEnough(vecOperation.apply(v, operand), ref);
+ });
+ }
+
+ /** */
+ private void consumeSampleVectors(BiConsumer<Vector, String> consumer) {
+ new VectorImplementationsFixtures().consumeSampleVectors(null, consumer);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java
new file mode 100644
index 0000000..5a46218
--- /dev/null
+++ b/modules/ml/src/test/java/org/apache/ignite/math/impls/vector/VectorImplementationsFixtures.java
@@ -0,0 +1,655 @@
+/*
+ * 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.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+import org.apache.ignite.math.impls.storage.vector.FunctionVectorStorage;
+import org.jetbrains.annotations.NotNull;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/** */
+class VectorImplementationsFixtures {
+ /** */
+ private static final List<Supplier<Iterable<Vector>>> suppliers = Arrays.asList(
+ (Supplier<Iterable<Vector>>)DenseLocalOnHeapVectorFixture::new,
+ (Supplier<Iterable<Vector>>)DenseLocalOffHeapVectorFixture::new,
+ (Supplier<Iterable<Vector>>)SparseLocalVectorFixture::new,
+ (Supplier<Iterable<Vector>>)RandomVectorFixture::new,
+ (Supplier<Iterable<Vector>>)ConstantVectorFixture::new,
+ (Supplier<Iterable<Vector>>)DelegatingVectorFixture::new,
+ (Supplier<Iterable<Vector>>)FunctionVectorFixture::new,
+ (Supplier<Iterable<Vector>>)SingleElementVectorFixture::new,
+ (Supplier<Iterable<Vector>>)PivotedVectorViewFixture::new,
+ (Supplier<Iterable<Vector>>)SingleElementVectorViewFixture::new,
+ (Supplier<Iterable<Vector>>)MatrixVectorViewFixture::new,
+ (Supplier<Iterable<Vector>>)SparseLocalOffHeapVectorFixture::new
+ );
+
+ /** */
+ void consumeSampleVectors(Consumer<Integer> paramsConsumer, BiConsumer<Vector, String> consumer) {
+ for (Supplier<Iterable<Vector>> fixtureSupplier : VectorImplementationsFixtures.suppliers) {
+ final Iterable<Vector> fixture = fixtureSupplier.get();
+
+ for (Vector v : fixture) {
+ if (paramsConsumer != null)
+ paramsConsumer.accept(v.size());
+
+ consumer.accept(v, fixture.toString());
+ }
+ }
+ }
+
+ /** */
+ void selfTest() {
+ new VectorSizesExtraIterator<>("VectorSizesExtraIterator test",
+ (size, shallowCp) -> new DenseLocalOnHeapVector(new double[size], shallowCp),
+ null, "shallow copy", new Boolean[] {false, true, null}).selfTest();
+
+ new VectorSizesIterator("VectorSizesIterator test", DenseLocalOffHeapVector::new, null).selfTest();
+ }
+
+ /** */
+ private static class DenseLocalOnHeapVectorFixture extends VectorSizesExtraFixture<Boolean> {
+ /** */
+ DenseLocalOnHeapVectorFixture() {
+ super("DenseLocalOnHeapVector",
+ (size, shallowCp) -> new DenseLocalOnHeapVector(new double[size], shallowCp),
+ "shallow copy", new Boolean[] {false, true, null});
+ }
+ }
+
+ /** */
+ private static class DenseLocalOffHeapVectorFixture extends VectorSizesFixture {
+ /** */
+ DenseLocalOffHeapVectorFixture() {
+ super("DenseLocalOffHeapVector", DenseLocalOffHeapVector::new);
+ }
+ }
+
+ /** */
+ private static class SparseLocalVectorFixture extends VectorSizesExtraFixture<Integer> {
+ /** */
+ SparseLocalVectorFixture() {
+ super("SparseLocalVector", SparseLocalVector::new, "access mode",
+ new Integer[] {StorageConstants.SEQUENTIAL_ACCESS_MODE, StorageConstants.RANDOM_ACCESS_MODE, null});
+ }
+ }
+
+ /** */
+ private static class RandomVectorFixture extends VectorSizesFixture {
+ /** */
+ RandomVectorFixture() {
+ super("RandomVector", RandomVector::new);
+ }
+ }
+
+ /** */
+ private static class ConstantVectorFixture extends VectorSizesExtraFixture<Double> {
+ /** */
+ ConstantVectorFixture() {
+ super("ConstantVector", ConstantVector::new,
+ "value", new Double[] {-1.0, 0.0, 0.5, 1.0, 2.0, null});
+ }
+ }
+
+ /** */
+ private static class FunctionVectorFixture extends VectorSizesExtraFixture<Double> {
+ /** */
+ FunctionVectorFixture() {
+ super("FunctionVector",
+ (size, scale) -> new FunctionVectorForTest(new double[size], scale),
+ "scale", new Double[] {0.5, 1.0, 2.0, null});
+ }
+ }
+
+ /** */
+ private static class SingleElementVectorFixture implements Iterable<Vector> {
+ /** */
+ private final Supplier<TwoParamsIterator<Integer, Double>> iter;
+
+ /** */
+ private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
+
+ /** */
+ SingleElementVectorFixture() {
+ iter = () -> new TwoParamsIterator<Integer, Double>("SingleElementVector",
+ null, ctxDescrHolder::set,
+ "size", new Integer[] {1, null},
+ "value", new Double[] {-1.0, 0.0, 0.5, 1.0, 2.0, null}) {
+
+ /** {@inheritDoc} */
+ @Override BiFunction<Integer, Double, Vector> ctor() {
+ return (size, value) -> new SingleElementVector(size, 0, value);
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Vector> iterator() {
+ return iter.get();//(
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return ctxDescrHolder.get();
+ }
+ }
+
+ /** */
+ private static class PivotedVectorViewFixture extends VectorSizesFixture {
+ /** */
+ PivotedVectorViewFixture() {
+ super("PivotedVectorView", PivotedVectorViewFixture::pivotedVectorView);
+ }
+
+ /** */
+ private static PivotedVectorView pivotedVectorView(int size) {
+ final DenseLocalOnHeapVector vec = new DenseLocalOnHeapVector(size);
+
+ final int[] pivot = new int[size];
+
+ for (int idx = 0; idx < size; idx++)
+ pivot[idx] = size - 1 - idx;
+
+ PivotedVectorView tmp = new PivotedVectorView(vec, pivot);
+
+ final int[] unpivot = new int[size];
+
+ for (int idx = 0; idx < size; idx++)
+ unpivot[idx] = tmp.unpivot(idx);
+
+ final int[] idxRecovery = new int[size];
+
+ for (int idx = 0; idx < size; idx++)
+ idxRecovery[idx] = idx;
+
+ return new PivotedVectorView(new PivotedVectorView(tmp, unpivot), idxRecovery);
+ }
+ }
+
+ /** */
+ private static class SingleElementVectorViewFixture implements Iterable<Vector> {
+ /** */
+ private final Supplier<TwoParamsIterator<Integer, Double>> iter;
+
+ /** */
+ private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
+
+ /** */
+ SingleElementVectorViewFixture() {
+ iter = () -> new TwoParamsIterator<Integer, Double>("SingleElementVectorView",
+ null, ctxDescrHolder::set,
+ "size", new Integer[] {1, null},
+ "value", new Double[] {-1.0, 0.0, 0.5, 1.0, 2.0, null}) {
+
+ /** {@inheritDoc} */
+ @Override BiFunction<Integer, Double, Vector> ctor() {
+ return (size, value) -> new SingleElementVectorView(new SingleElementVector(size, 0, value), 0);
+ }
+ };
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Vector> iterator() {
+ return iter.get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return ctxDescrHolder.get();
+ }
+ }
+
+ /** */
+ private static class MatrixVectorViewFixture extends VectorSizesExtraFixture<Integer> {
+ /** */
+ MatrixVectorViewFixture() {
+ super("MatrixVectorView",
+ MatrixVectorViewFixture::newView,
+ "stride kind", new Integer[] {0, 1, 2, null});
+ }
+
+ /** */
+ private static Vector newView(int size, int strideKind) {
+ final Matrix parent = new DenseLocalOnHeapMatrix(size, size);
+
+ return new MatrixVectorView(parent, 0, 0, strideKind != 1 ? 1 : 0, strideKind != 0 ? 1 : 0);
+ }
+ }
+
+ /** */
+ private static class VectorSizesExtraFixture<T> implements Iterable<Vector> {
+ /** */
+ private final Supplier<VectorSizesExtraIterator<T>> iter;
+
+ /** */
+ private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
+
+ /** */
+ VectorSizesExtraFixture(String vectorKind, BiFunction<Integer, T, Vector> ctor, String extraParamName,
+ T[] extras) {
+ iter = () -> new VectorSizesExtraIterator<>(vectorKind, ctor, ctxDescrHolder::set, extraParamName, extras);
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Vector> iterator() {
+ return iter.get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return ctxDescrHolder.get();
+ }
+ }
+
+ /** */
+ private static abstract class VectorSizesFixture implements Iterable<Vector> {
+ /** */
+ private final Supplier<VectorSizesIterator> iter;
+
+ /** */
+ private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
+
+ /** */
+ VectorSizesFixture(String vectorKind, Function<Integer, Vector> ctor) {
+ iter = () -> new VectorSizesIterator(vectorKind, ctor, ctxDescrHolder::set);
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Vector> iterator() {
+ return iter.get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return ctxDescrHolder.get();
+ }
+ }
+
+ /** */
+ private static class VectorSizesExtraIterator<T> extends VectorSizesIterator {
+ /** */
+ private final T[] extras;
+ /** */
+ private int extraIdx = 0;
+ /** */
+ private final BiFunction<Integer, T, Vector> ctor;
+ /** */
+ private final String extraParamName;
+
+ /**
+ * @param vectorKind Descriptive name to use for context logging.
+ * @param ctor Constructor for objects to iterate over.
+ * @param ctxDescrConsumer Context logging consumer.
+ * @param extraParamName Name of extra parameter to iterate over.
+ * @param extras Array of extra parameter values to iterate over.
+ */
+ VectorSizesExtraIterator(String vectorKind, BiFunction<Integer, T, Vector> ctor,
+ Consumer<String> ctxDescrConsumer, String extraParamName, T[] extras) {
+ super(vectorKind, null, ctxDescrConsumer);
+
+ this.ctor = ctor;
+ this.extraParamName = extraParamName;
+ this.extras = extras;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return super.hasNext() && hasNextExtra(extraIdx);
+ }
+
+ /** {@inheritDoc} */
+ @Override void nextIdx() {
+ assert extras[extraIdx] != null
+ : "Index(es) out of bound at " + VectorSizesExtraIterator.this;
+
+ if (hasNextExtra(extraIdx + 1)) {
+ extraIdx++;
+
+ return;
+ }
+
+ extraIdx = 0;
+
+ super.nextIdx();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return "{" + super.toString() +
+ ", " + extraParamName + "=" + extras[extraIdx] +
+ '}';
+ }
+
+ /** {@inheritDoc} */
+ @Override BiFunction<Integer, Integer, Vector> ctor() {
+ return (size, delta) -> ctor.apply(size + delta, extras[extraIdx]);
+ }
+
+ /** */
+ void selfTest() {
+ final Set<Integer> extraIdxs = new HashSet<>();
+
+ int cnt = 0;
+
+ while (hasNext()) {
+ assertNotNull("Expect not null vector at " + this, next());
+
+ if (extras[extraIdx] != null)
+ extraIdxs.add(extraIdx);
+
+ cnt++;
+ }
+
+ assertEquals("Extra param tested", extraIdxs.size(), extras.length - 1);
+
+ assertEquals("Combinations tested mismatch.",
+ 7 * 3 * (extras.length - 1), cnt);
+ }
+
+ /** */
+ private boolean hasNextExtra(int idx) {
+ return extras[idx] != null;
+ }
+ }
+
+ /** */
+ private static class VectorSizesIterator extends TwoParamsIterator<Integer, Integer> {
+ /** */
+ private final Function<Integer, Vector> ctor;
+
+ /** */
+ VectorSizesIterator(String vectorKind, Function<Integer, Vector> ctor, Consumer<String> ctxDescrConsumer) {
+ super(vectorKind, null, ctxDescrConsumer,
+ "size", new Integer[] {2, 4, 8, 16, 32, 64, 128, null},
+ "size delta", new Integer[] {-1, 0, 1, null});
+
+ this.ctor = ctor;
+ }
+
+ /** {@inheritDoc} */
+ @Override BiFunction<Integer, Integer, Vector> ctor() {
+ return (size, delta) -> ctor.apply(size + delta);
+ }
+ }
+
+ /** */
+ private static class TwoParamsIterator<T, U> implements Iterator<Vector> {
+ /** */
+ private final T params1[];
+
+ /** */
+ private final U params2[];
+
+ /** */
+ private final String vectorKind;
+
+ /** */
+ private final String param1Name;
+
+ /** */
+ private final String param2Name;
+
+ /** */
+ private final BiFunction<T, U, Vector> ctor;
+
+ /** */
+ private final Consumer<String> ctxDescrConsumer;
+
+ /** */
+ private int param1Idx = 0;
+
+ /** */
+ private int param2Idx = 0;
+
+ /** */
+ TwoParamsIterator(String vectorKind, BiFunction<T, U, Vector> ctor,
+ Consumer<String> ctxDescrConsumer, String param1Name, T[] params1, String param2Name, U[] params2) {
+ this.param1Name = param1Name;
+ this.params1 = params1;
+
+ this.param2Name = param2Name;
+ this.params2 = params2;
+
+ this.vectorKind = vectorKind;
+
+ this.ctor = ctor;
+
+ this.ctxDescrConsumer = ctxDescrConsumer;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean hasNext() {
+ return hasNextParam1(param1Idx) && hasNextParam2(param2Idx);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector next() {
+ if (!hasNext())
+ throw new NoSuchElementException(TwoParamsIterator.this.toString());
+
+ if (ctxDescrConsumer != null)
+ ctxDescrConsumer.accept(toString());
+
+ Vector res = ctor().apply(params1[param1Idx], params2[param2Idx]);
+
+ nextIdx();
+
+ return res;
+ }
+
+ /** */
+ void selfTest() {
+ final Set<Integer> sizeIdxs = new HashSet<>(), deltaIdxs = new HashSet<>();
+
+ int cnt = 0;
+
+ while (hasNext()) {
+ assertNotNull("Expect not null vector at " + this, next());
+
+ if (params1[param1Idx] != null)
+ sizeIdxs.add(param1Idx);
+
+ if (params2[param2Idx] != null)
+ deltaIdxs.add(param2Idx);
+
+ cnt++;
+ }
+
+ assertEquals("Sizes tested mismatch.", sizeIdxs.size(), params1.length - 1);
+
+ assertEquals("Deltas tested", deltaIdxs.size(), params2.length - 1);
+
+ assertEquals("Combinations tested mismatch.",
+ (params1.length - 1) * (params2.length - 1), cnt);
+ }
+
+ /** IMPL NOTE override in subclasses if needed */
+ void nextIdx() {
+ assert params1[param1Idx] != null && params2[param2Idx] != null
+ : "Index(es) out of bound at " + TwoParamsIterator.this;
+
+ if (hasNextParam2(param2Idx + 1)) {
+ param2Idx++;
+
+ return;
+ }
+
+ param2Idx = 0;
+
+ param1Idx++;
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return vectorKind + "{" + param1Name + "=" + params1[param1Idx] +
+ ", " + param2Name + "=" + params2[param2Idx] +
+ '}';
+ }
+
+ /** IMPL NOTE override in subclasses if needed */
+ BiFunction<T, U, Vector> ctor() {
+ return ctor;
+ }
+
+ /** */
+ private boolean hasNextParam1(int idx) {
+ return params1[idx] != null;
+ }
+
+ /** */
+ private boolean hasNextParam2(int idx) {
+ return params2[idx] != null;
+ }
+ }
+
+ /** Delegating vector with dense local onheap vector */
+ private static class DelegatingVectorFixture implements Iterable<Vector> {
+
+ /** */
+ private final Supplier<VectorSizesExtraIterator<Boolean>> iter;
+
+ /** */
+ private final AtomicReference<String> ctxDescrHolder = new AtomicReference<>("Iterator not started.");
+
+ /** */
+ DelegatingVectorFixture() {
+ iter = () -> new VectorSizesExtraIterator<>("DelegatingVector with DenseLocalOnHeapVector",
+ (size, shallowCp) -> new DelegatingVector(new DenseLocalOnHeapVector(new double[size], shallowCp)),
+ ctxDescrHolder::set, "shallow copy", new Boolean[] {false, true, null});
+ }
+
+ /** {@inheritDoc} */
+ @NotNull
+ @Override public Iterator<Vector> iterator() {
+ return iter.get();
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ // IMPL NOTE index within bounds is expected to be guaranteed by proper code in this class
+ return ctxDescrHolder.get();
+ }
+ }
+
+ /** Subclass tweaked for serialization */
+ private static class FunctionVectorForTest extends FunctionVector {
+ /** */
+ double[] arr;
+
+ /** */
+ double scale;
+
+ /** */
+ public FunctionVectorForTest() {
+ // No-op.
+ }
+
+ /** */
+ FunctionVectorForTest(double[] arr, double scale) {
+ super(arr.length, idx -> arr[idx] * scale, (idx, value) -> arr[idx] = value / scale);
+
+ this.arr = arr;
+
+ this.scale = scale;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+
+ out.writeObject(arr);
+
+ out.writeDouble(scale);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+
+ arr = (double[])in.readObject();
+
+ scale = in.readDouble();
+
+ setStorage(new FunctionVectorStorage(arr.length, idx -> arr[idx] * scale, (idx, value) -> arr[idx] = value / scale));
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + Double.hashCode(scale);
+ res = res * 37 + Integer.hashCode(getStorage().size());
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ FunctionVectorForTest that = (FunctionVectorForTest)o;
+
+ return new Double(scale).equals(that.scale)
+ && (arr != null ? Arrays.equals(arr, that.arr) : that.arr == null);
+ }
+ }
+
+ /** */
+ private static class SparseLocalOffHeapVectorFixture extends VectorSizesFixture {
+
+ /** */
+ SparseLocalOffHeapVectorFixture() {
+ super("SparseLocalOffHeapVector", SparseLocalOffHeapVector::new);
+ }
+ }
+}
[25/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/CacheVectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/CacheVectorExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/CacheVectorExample.java
deleted file mode 100644
index dd0fcb3..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/CacheVectorExample.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * 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.examples.java8.math.vector;
-
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.Ignition;
-import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.math.IdentityValueMapper;
-import org.apache.ignite.math.ValueMapper;
-import org.apache.ignite.math.VectorKeyMapper;
-import org.apache.ignite.math.impls.vector.CacheVector;
-
-/**
- * This example shows how to use {@link CacheVector} API.
- */
-public class CacheVectorExample {
- /** */ private static final String CACHE_NAME = CacheVectorExample.class.getSimpleName();
- /** */ private static final int CARDINALITY = 10;
-
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
- System.out.println();
- System.out.println(">>> CacheVector example started.");
-
- CacheConfiguration<Integer, Double> cfg = new CacheConfiguration<>();
-
- cfg.setName(CACHE_NAME);
-
- try (IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(cfg)) {
- double[] testValues1 = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
- double[] testValues2 = {0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
-
- ValueMapper valMapper = new IdentityValueMapper();
-
- // Map vector element index to cache keys.
- VectorKeyMapper<Integer> keyMapper1 = new VectorKeyMapper<Integer>() {
- @Override public Integer apply(int i) {
- return i;
- }
-
- @Override public boolean isValid(Integer integer) {
- return integer >= 0 && CARDINALITY > integer;
- }
- };
-
- // Map vector element index to cache keys with shift.
- VectorKeyMapper<Integer> keyMapper2 = new VectorKeyMapper<Integer>() {
- @Override public Integer apply(int i) {
- return i + CARDINALITY;
- }
-
- @Override public boolean isValid(Integer integer) {
- return integer >= 0 && CARDINALITY > integer;
- }
- };
-
- // Create two cache vectors over one cache.
- CacheVector cacheVector1 = new CacheVector(CARDINALITY, cache, keyMapper1, valMapper);
- System.out.println(">>> First cache vector created.");
-
- CacheVector cacheVector2 = new CacheVector(CARDINALITY, cache, keyMapper2, valMapper);
- System.out.println(">>> Second cache vector created.");
-
- cacheVector1.assign(testValues1);
- cacheVector2.assign(testValues2);
-
- // Dot product for orthogonal vectors is 0.0.
- assert cacheVector1.dot(cacheVector2) == 0.0;
-
- System.out.println(">>>");
- System.out.println(">>> Finished executing Ignite \"CacheVector\" example.");
- System.out.println(">>> Dot product is 0.0 for orthogonal vectors.");
- System.out.println(">>>");
- }
- finally {
- // Distributed cache could be removed from cluster only by #destroyCache() call.
- ignite.destroyCache(CACHE_NAME);
- }
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/ExampleVectorStorage.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/ExampleVectorStorage.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/ExampleVectorStorage.java
deleted file mode 100644
index 3b88e0a..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/ExampleVectorStorage.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * 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.examples.java8.math.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Arrays;
-
-import org.apache.ignite.math.VectorStorage;
-
-/**
- * Example vector storage, modeled after {@link org.apache.ignite.math.impls.storage.vector.ArrayVectorStorage}.
- */
-class ExampleVectorStorage implements VectorStorage {
- /** */
- private double[] data;
-
- /**
- * IMPL NOTE required by Externalizable
- */
- public ExampleVectorStorage() {
- // No-op.
- }
-
- /**
- * @param data backing data array.
- */
- ExampleVectorStorage(double[] data) {
- assert data != null;
-
- this.data = data;
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return data == null ? 0 : data.length;
- }
-
- /** {@inheritDoc} */
- @Override public double get(int i) {
- return data[i];
- }
-
- /** {@inheritDoc} */
- @Override public void set(int i, double v) {
- data[i] = v;
- }
-
- /** {@inheritDoc}} */
- @Override public boolean isArrayBased() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public double[] data() {
- return data;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return true;
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return false;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(data);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- data = (double[])in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + Arrays.hashCode(data);
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object obj) {
- if (this == obj)
- return true;
-
- if (obj == null || getClass() != obj.getClass())
- return false;
-
- ExampleVectorStorage that = (ExampleVectorStorage)obj;
-
- return Arrays.equals(data, (that.data));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/OffHeapVectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/OffHeapVectorExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/OffHeapVectorExample.java
deleted file mode 100644
index 7184245..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/OffHeapVectorExample.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * 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.examples.java8.math.vector;
-
-import java.util.Arrays;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVector;
-
-/**
- * This example shows how to use off-heap {@link Vector} API.
- */
-public final class OffHeapVectorExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Off-heap vector API usage example started.");
-
- System.out.println("\n>>> Creating perpendicular off-heap vectors.");
- double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
- double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
-
- Vector v1 = new DenseLocalOffHeapVector(data1.length);
- Vector v2 = new DenseLocalOffHeapVector(data2.length);
-
- v1.assign(data1);
- v2.assign(data2);
-
- System.out.println(">>> First vector: " + Arrays.toString(data1));
- System.out.println(">>> Second vector: " + Arrays.toString(data2));
-
- double dotProduct = v1.dot(v2);
- boolean dotProductIsAsExp = dotProduct == 0;
-
- System.out.println("\n>>> Dot product of vectors: [" + dotProduct
- + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
-
- assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
-
- Vector hypotenuse = v1.plus(v2);
-
- System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
-
- double lenSquared1 = v1.getLengthSquared();
- double lenSquared2 = v2.getLengthSquared();
- double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
-
- boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
-
- System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
- System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
- System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
- + "], equals sum of squared lengths of two original vectors as expected: ["
- + lenSquaredHypotenuseIsAsExp + "].");
-
- assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
-
- System.out.println("\n>>> Off-heap vector API usage example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/SparseVectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/SparseVectorExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/SparseVectorExample.java
deleted file mode 100644
index 79e0567..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/SparseVectorExample.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * 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.examples.java8.math.vector;
-
-import java.util.Arrays;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.vector.SparseLocalVector;
-
-import static org.apache.ignite.math.StorageConstants.RANDOM_ACCESS_MODE;
-
-/**
- * This example shows how to use sparse {@link Vector} API.
- */
-public final class SparseVectorExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Sparse vector API usage example started.");
-
- System.out.println("\n>>> Creating perpendicular sparse vectors.");
- double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
- double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
-
- Vector v1 = new SparseLocalVector(data1.length, RANDOM_ACCESS_MODE);
- Vector v2 = new SparseLocalVector(data2.length, RANDOM_ACCESS_MODE);
-
- v1.assign(data1);
- v2.assign(data2);
-
- System.out.println(">>> First vector: " + Arrays.toString(data1));
- System.out.println(">>> Second vector: " + Arrays.toString(data2));
-
- double dotProduct = v1.dot(v2);
- boolean dotProductIsAsExp = dotProduct == 0;
-
- System.out.println("\n>>> Dot product of vectors: [" + dotProduct
- + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
-
- assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
-
- Vector hypotenuse = v1.plus(v2);
-
- System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
-
- double lenSquared1 = v1.getLengthSquared();
- double lenSquared2 = v2.getLengthSquared();
- double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
-
- boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
-
- System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
- System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
- System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
- + "], equals sum of squared lengths of two original vectors as expected: ["
- + lenSquaredHypotenuseIsAsExp + "].");
-
- assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
-
- System.out.println("\n>>> Sparse vector API usage example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorCustomStorageExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorCustomStorageExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorCustomStorageExample.java
deleted file mode 100644
index b2778c5..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorCustomStorageExample.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * 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.examples.java8.math.vector;
-
-import java.util.Arrays;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.vector.AbstractVector;
-
-/**
- * This example shows how to use {@link Vector} based on custom {@link VectorStorage}.
- */
-public final class VectorCustomStorageExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Vector custom storage API usage example started.");
-
- System.out.println("\n>>> Creating perpendicular vectors.");
- double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
- double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
-
- Vector v1 = new VectorCustomStorage(data1);
- Vector v2 = new VectorCustomStorage(data2);
-
- System.out.println(">>> First vector: " + Arrays.toString(data1));
- System.out.println(">>> Second vector: " + Arrays.toString(data2));
-
- double dotProduct = v1.dot(v2);
- boolean dotProductIsAsExp = dotProduct == 0;
-
- System.out.println("\n>>> Dot product of vectors: [" + dotProduct
- + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
-
- assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
-
- Vector hypotenuse = v1.plus(v2);
-
- System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
-
- double lenSquared1 = v1.getLengthSquared();
- double lenSquared2 = v2.getLengthSquared();
- double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
-
- boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
-
- System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
- System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
- System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
- + "], equals sum of squared lengths of two original vectors as expected: ["
- + lenSquaredHypotenuseIsAsExp + "].");
-
- assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
-
- System.out.println("\n>>> Vector custom storage API usage example completed.");
- }
-
- /**
- * Example of vector with custom storage, modeled after
- * {@link org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector}.
- */
- static class VectorCustomStorage extends AbstractVector {
- /**
- * @param arr Source array.
- * @param cp {@code true} to clone array, reuse it otherwise.
- */
- private VectorStorage mkStorage(double[] arr, boolean cp) {
- assert arr != null;
-
- return new ExampleVectorStorage(cp ? arr.clone() : arr);
- }
-
- /** */
- public VectorCustomStorage() {
- // No-op.
- }
-
- /**
- * @param arr Source array.
- * @param shallowCp {@code true} to use shallow copy.
- */
- VectorCustomStorage(double[] arr, boolean shallowCp) {
- setStorage(mkStorage(arr, shallowCp));
- }
-
- /**
- * @param arr Source array.
- */
- VectorCustomStorage(double[] arr) {
- this(arr, false);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return new DenseLocalOnHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc */
- @Override public Vector like(int crd) {
- return new org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector(crd);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorExample.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorExample.java
deleted file mode 100644
index f852f0a..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/VectorExample.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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.examples.java8.math.vector;
-
-import java.util.Arrays;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
-
-/**
- * This example shows how to use {@link Vector} API.
- */
-public final class VectorExample {
- /**
- * Executes example.
- *
- * @param args Command line arguments, none required.
- */
- public static void main(String[] args) {
- System.out.println();
- System.out.println(">>> Basic Vector API usage example started.");
-
- System.out.println("\n>>> Creating perpendicular vectors.");
- double[] data1 = new double[] {1, 0, 3, 0, 5, 0};
- double[] data2 = new double[] {0, 2, 0, 4, 0, 6};
-
- Vector v1 = new DenseLocalOnHeapVector(data1);
- Vector v2 = new DenseLocalOnHeapVector(data2);
-
- System.out.println(">>> First vector: " + Arrays.toString(data1));
- System.out.println(">>> Second vector: " + Arrays.toString(data2));
-
- double dotProduct = v1.dot(v2);
- boolean dotProductIsAsExp = dotProduct == 0;
-
- System.out.println("\n>>> Dot product of vectors: [" + dotProduct
- + "], it is 0 as expected: [" + dotProductIsAsExp + "].");
-
- assert dotProductIsAsExp : "Expect dot product of perpendicular vectors to be 0.";
-
- Vector hypotenuse = v1.plus(v2);
-
- System.out.println("\n>>> Hypotenuse (sum of vectors): " + Arrays.toString(hypotenuse.getStorage().data()));
-
- double lenSquared1 = v1.getLengthSquared();
- double lenSquared2 = v2.getLengthSquared();
- double lenSquaredHypotenuse = hypotenuse.getLengthSquared();
-
- boolean lenSquaredHypotenuseIsAsExp = lenSquaredHypotenuse == lenSquared1 + lenSquared2;
-
- System.out.println(">>> Squared length of first vector: [" + lenSquared1 + "].");
- System.out.println(">>> Squared length of second vector: [" + lenSquared2 + "].");
- System.out.println(">>> Squared length of hypotenuse: [" + lenSquaredHypotenuse
- + "], equals sum of squared lengths of two original vectors as expected: ["
- + lenSquaredHypotenuseIsAsExp + "].");
-
- assert lenSquaredHypotenuseIsAsExp : "Expect squared length of hypotenuse to be as per Pythagorean theorem.";
-
- System.out.println("\n>>> Basic Vector API usage example completed.");
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/package-info.java b/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/package-info.java
deleted file mode 100644
index ff09e4e..0000000
--- a/examples/src/main/java8/org/apache/ignite/examples/java8/math/vector/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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. -->
- * Core algebra vector examples.
- */
-package org.apache.ignite.examples.java8.math.vector;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/CholeskyDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/CholeskyDecompositionExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/CholeskyDecompositionExample.java
new file mode 100644
index 0000000..07308f5
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/CholeskyDecompositionExample.java
@@ -0,0 +1,80 @@
+/*
+ * 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.examples.ml.math.decompositions;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Tracer;
+import org.apache.ignite.math.decompositions.CholeskyDecomposition;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+
+/**
+ * Example of using {@link CholeskyDecomposition}.
+ */
+public class CholeskyDecompositionExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println(">>> Cholesky decomposition example started.");
+ // Let's compute a Cholesky decomposition of Hermitian matrix m:
+ // m = l l^{*}, where
+ // l is a lower triangular matrix
+ // l^{*} is its conjugate transpose
+
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
+ {2.0d, -1.0d, 0.0d},
+ {-1.0d, 2.0d, -1.0d},
+ {0.0d, -1.0d, 2.0d}
+ });
+ System.out.println("\n>>> Matrix m for decomposition: ");
+ Tracer.showAscii(m);
+
+ // This decomposition is useful when dealing with systems of linear equations of the form
+ // m x = b where m is a Hermitian matrix.
+ // For such systems Cholesky decomposition provides
+ // more effective method of solving compared to LU decomposition.
+ // Suppose we want to solve system
+ // m x = b for various bs. Then after we computed Cholesky decomposition, we can feed various bs
+ // as a matrix of the form
+ // (b1, b2, ..., bm)
+ // to the method Cholesky::solve which returns solutions in the form
+ // (sol1, sol2, ..., solm)
+ CholeskyDecomposition dec = new CholeskyDecomposition(m);
+ System.out.println("\n>>> Made decomposition m = l * l^{*}.");
+ System.out.println(">>> Matrix l is ");
+ Tracer.showAscii(dec.getL());
+ System.out.println(">>> Matrix l^{*} is ");
+ Tracer.showAscii(dec.getLT());
+
+ Matrix bs = new DenseLocalOnHeapMatrix(new double[][] {
+ {4.0, -6.0, 7.0},
+ {1.0, 1.0, 1.0}
+ }).transpose();
+ System.out.println("\n>>> Solving systems of linear equations of the form m x = b for various bs represented by columns of matrix");
+ Tracer.showAscii(bs);
+ Matrix sol = dec.solve(bs);
+
+ System.out.println("\n>>> List of solutions: ");
+ for (int i = 0; i < sol.columnSize(); i++)
+ Tracer.showAscii(sol.viewColumn(i));
+
+ System.out.println("\n>>> Cholesky decomposition example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/EigenDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/EigenDecompositionExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/EigenDecompositionExample.java
new file mode 100644
index 0000000..16e692b
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/EigenDecompositionExample.java
@@ -0,0 +1,69 @@
+/*
+ * 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.examples.ml.math.decompositions;
+
+import org.apache.ignite.math.Tracer;
+import org.apache.ignite.math.decompositions.EigenDecomposition;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+
+/**
+ * Example of using {@link EigenDecomposition}.
+ */
+public class EigenDecompositionExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println(">>> Eigen decomposition example started.");
+
+ // Let's compute EigenDecomposition for some square (n x n) matrix m with real eigenvalues:
+ // m = v d v^{-1}, where d is diagonal matrix having eigenvalues of m on diagonal
+ // and v is matrix where i-th column is eigenvector for i-th eigenvalue (i from 0 to n - 1)
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
+ {1.0d, 0.0d, 0.0d, 0.0d},
+ {0.0d, 1.0d, 0.0d, 0.0d},
+ {0.0d, 0.0d, 2.0d, 0.0d},
+ {1.0d, 1.0d, 0.0d, 2.0d}
+ });
+ System.out.println("\n>>> Matrix m for decomposition: ");
+ Tracer.showAscii(m);
+
+ EigenDecomposition dec = new EigenDecomposition(m);
+ System.out.println("\n>>> Made decomposition.");
+ System.out.println(">>> Matrix getV is ");
+ Tracer.showAscii(dec.getV());
+ System.out.println(">>> Matrix getD is ");
+ Tracer.showAscii(dec.getD());
+
+ // From this decomposition we, for example, can easily compute determinant of matrix m
+ // det (m) = det (v d v^{-1}) =
+ // det(v) det (d) det(v^{-1}) =
+ // det(v) det(v)^{-1} det(d) =
+ // det (d) =
+ // product of diagonal elements of d =
+ // product of eigenvalues
+ double det = dec.getRealEigenValues().foldMap(Functions.MULT, Functions.IDENTITY, 1.0);
+ System.out.println("\n>>> Determinant is " + det);
+
+ System.out.println("\n>>> Eigen decomposition example completed.");
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/LUDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/LUDecompositionExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/LUDecompositionExample.java
new file mode 100644
index 0000000..c670eab
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/LUDecompositionExample.java
@@ -0,0 +1,83 @@
+/*
+ * 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.examples.ml.math.decompositions;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Tracer;
+import org.apache.ignite.math.decompositions.LUDecomposition;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+
+/**
+ * Example of using {@link LUDecomposition}.
+ */
+public class LUDecompositionExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println(">>> LU decomposition example started.");
+ // Let's compute a LU decomposition for some (n x n) matrix m:
+ // m = p l u, where
+ // p is an (n x n) is a row-permutation matrix
+ // l is a (n x n) lower triangular matrix
+ // u is a (n x n) upper triangular matrix
+
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
+ {1.0d, 1.0d, -1.0d},
+ {1.0d, -2.0d, 3.0d},
+ {2.0d, 3.0d, 1.0d}
+ });
+ System.out.println("\n>>> Matrix m for decomposition: ");
+ Tracer.showAscii(m);
+
+ // This decomposition is useful when dealing with systems of linear equations.
+ // (see https://en.wikipedia.org/wiki/LU_decomposition)
+ // suppose we want to solve system
+ // m x = b for various bs. Then after we computed LU decomposition, we can feed various bs
+ // as a matrix of the form
+ // (b1, b2, ..., bm)
+ // to the method LUDecomposition::solve which returns solutions in the form
+ // (sol1, sol2, ..., solm)
+
+ LUDecomposition dec = new LUDecomposition(m);
+ System.out.println("\n>>> Made decomposition.");
+ System.out.println(">>> Matrix getL is ");
+ Tracer.showAscii(dec.getL());
+ System.out.println(">>> Matrix getU is ");
+ Tracer.showAscii(dec.getU());
+ System.out.println(">>> Matrix getP is ");
+ Tracer.showAscii(dec.getP());
+
+ Matrix bs = new DenseLocalOnHeapMatrix(new double[][] {
+ {4.0, -6.0, 7.0},
+ {1.0, 1.0, 1.0}
+ });
+ System.out.println("\n>>> Matrix to solve: ");
+ Tracer.showAscii(bs);
+
+ Matrix sol = dec.solve(bs.transpose());
+
+ System.out.println("\n>>> List of solutions: ");
+ for (int i = 0; i < sol.columnSize(); i++)
+ Tracer.showAscii(sol.viewColumn(i));
+
+ System.out.println("\n>>> LU decomposition example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/SingularValueDecompositionExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/SingularValueDecompositionExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/SingularValueDecompositionExample.java
new file mode 100644
index 0000000..281fbc4
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/SingularValueDecompositionExample.java
@@ -0,0 +1,70 @@
+/*
+ * 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.examples.ml.math.decompositions;
+
+import org.apache.ignite.math.Tracer;
+import org.apache.ignite.math.decompositions.SingularValueDecomposition;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+
+/**
+ * Example of using {@link SingularValueDecomposition}.
+ */
+public class SingularValueDecompositionExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println(">>> Singular value decomposition (SVD) example started.");
+
+ // Let's compute a SVD of (l x k) matrix m. This decomposition can be thought as extension of EigenDecomposition to
+ // rectangular matrices. The factorization we get is following:
+ // m = u * s * v^{*}, where
+ // u is a real or complex unitary matrix
+ // s is a rectangular diagonal matrix with non-negative real numbers on diagonal (this numbers are singular values of m)
+ // v is a real or complex unitary matrix
+ // If m is real then u and v are also real.
+ // Complex case is not supported for the moment.
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
+ {1.0d, 0.0d, 0.0d, 0.0d, 2.0d},
+ {0.0d, 0.0d, 3.0d, 0.0d, 0.0d},
+ {0.0d, 0.0d, 0.0d, 0.0d, 0.0d},
+ {0.0d, 2.0d, 0.0d, 0.0d, 0.0d}
+ });
+ System.out.println("\n>>> Matrix m for decomposition: ");
+ Tracer.showAscii(m);
+
+ SingularValueDecomposition dec = new SingularValueDecomposition(m);
+ System.out.println("\n>>> Made decomposition m = u * s * v^{*}.");
+ System.out.println(">>> Matrix u is ");
+ Tracer.showAscii(dec.getU());
+ System.out.println(">>> Matrix s is ");
+ Tracer.showAscii(dec.getS());
+ System.out.println(">>> Matrix v is ");
+ Tracer.showAscii(dec.getV());
+
+ // This decomposition can in particular help with solving problem of finding x minimizing 2-norm of m x such
+ // that 2-norm of x is 1. It appears that it is the right singular vector corresponding to minimal singular
+ // value, which is always last.
+ System.out.println("\n>>> Vector x minimizing 2-norm of m x such that 2 norm of x is 1: ");
+ Tracer.showAscii(dec.getV().viewColumn(dec.getSingularValues().length - 1));
+
+ System.out.println("\n>>> Singular value decomposition (SVD) example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/package-info.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/decompositions/package-info.java
new file mode 100644
index 0000000..644f8ba
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/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. -->
+ * Core algebra decomposition examples.
+ */
+package org.apache.ignite.examples.ml.math.decompositions;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/CacheMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/CacheMatrixExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/CacheMatrixExample.java
new file mode 100644
index 0000000..80f861f
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/CacheMatrixExample.java
@@ -0,0 +1,91 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.math.IdentityValueMapper;
+import org.apache.ignite.math.MatrixKeyMapper;
+import org.apache.ignite.math.ValueMapper;
+import org.apache.ignite.math.functions.Functions;
+import org.apache.ignite.math.impls.matrix.CacheMatrix;
+
+/** */
+public class CacheMatrixExample {
+ /** */ private static final String CACHE_NAME = CacheMatrixExample.class.getSimpleName();
+ /** */ private static final int ROWS = 3;
+ /** */ private static final int COLS = 3;
+
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
+ System.out.println();
+ System.out.println(">>> CacheMatrix example started.");
+
+ CacheConfiguration<Integer, Double> cfg = new CacheConfiguration<>();
+
+ cfg.setName(CACHE_NAME);
+
+ try (IgniteCache<Integer, Double> cache = ignite.getOrCreateCache(cfg)) {
+ double[][] testValues = {{1.0, 0.0, 0.0}, {1.0, 1.0, 0.0}, {1.0, 1.0, 1.0}};
+
+ ValueMapper valMapper = new IdentityValueMapper();
+
+ // Map matrix element indices to cache keys.
+ MatrixKeyMapper<Integer> keyMapper = new MatrixKeyMapper<Integer>() {
+ @Override public Integer apply(int x, int y) {
+ return x * COLS + y;
+ }
+
+ @Override public boolean isValid(Integer integer) {
+ return integer >= 0 && integer < COLS * ROWS;
+ }
+ };
+
+ // Create cache matrix.
+ CacheMatrix<Integer, Double> cacheMatrix = new CacheMatrix<>(ROWS, COLS, cache, keyMapper, valMapper);
+
+ cacheMatrix.assign(testValues);
+
+ // Find all positive elements.
+ Integer nonZeroes = cacheMatrix.foldMap((o, aDouble) -> {
+ if (aDouble > 0)
+ return o + 1;
+ return o;
+ }, Functions.IDENTITY, 0);
+
+ assert nonZeroes.equals(6);
+
+ System.out.println(">>>");
+ System.out.println(">>> Finished executing Ignite \"CacheMatrix\" example.");
+ System.out.println(">>> Lower triangular matrix 3x3 have only 6 positive elements.");
+ System.out.println(">>>");
+ }
+ finally {
+ // Distributed cache could be removed from cluster only by #destroyCache() call.
+ ignite.destroyCache(CACHE_NAME);
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/ExampleMatrixStorage.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/ExampleMatrixStorage.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/ExampleMatrixStorage.java
new file mode 100644
index 0000000..d0c8604
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/ExampleMatrixStorage.java
@@ -0,0 +1,162 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+
+import org.apache.ignite.math.MatrixStorage;
+
+/**
+ * Example matrix storage, modeled after {@link org.apache.ignite.math.impls.storage.matrix.ArrayMatrixStorage}.
+ */
+class ExampleMatrixStorage implements MatrixStorage {
+ /** Backing data array. */
+ private double[][] data;
+ /** Amount of rows in a matrix storage. */
+ private int rows;
+ /** Amount of columns in a matrix storage. */
+ private int cols;
+
+ /**
+ *
+ */
+ public ExampleMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in a matrix storage.
+ * @param cols Amount of columns in a matrix storage.
+ */
+ ExampleMatrixStorage(int rows, int cols) {
+ assert rows > 0;
+ assert cols > 0;
+
+ this.data = new double[rows][cols];
+ this.rows = rows;
+ this.cols = cols;
+ }
+
+ /**
+ * @param data Backing data array.
+ */
+ ExampleMatrixStorage(double[][] data) {
+ assert data != null;
+ assert data[0] != null;
+
+ this.data = data;
+ this.rows = data.length;
+ this.cols = data[0].length;
+
+ assert rows > 0;
+ assert cols > 0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return data[x][y];
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ data[x][y] = v;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[][] data() {
+ return data;
+ }
+
+ /** {@inheritDoc */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+
+ out.writeObject(data);
+ }
+
+ /** {@inheritDoc */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+
+ data = (double[][])in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res += res * 37 + rows;
+ res += res * 37 + cols;
+ res += res * 37 + Arrays.deepHashCode(data);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ ExampleMatrixStorage that = (ExampleMatrixStorage)o;
+
+ return Arrays.deepEquals(data, that.data);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixCustomStorageExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixCustomStorageExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixCustomStorageExample.java
new file mode 100644
index 0000000..b3df9f1
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixCustomStorageExample.java
@@ -0,0 +1,141 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.impls.matrix.AbstractMatrix;
+import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVector;
+
+/**
+ * This example shows how to use {@link Matrix} API based on custom {@link MatrixStorage}.
+ */
+public final class MatrixCustomStorageExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Matrix API usage example started.");
+
+ System.out.println("\n>>> Creating a matrix to be transposed.");
+ double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
+ Matrix m = new MatrixCustomStorage(data);
+ Matrix transposed = m.transpose();
+
+ System.out.println(">>> Matrix: ");
+ MatrixExampleUtil.print(m);
+ System.out.println(">>> Transposed matrix: ");
+ MatrixExampleUtil.print(transposed);
+
+ MatrixExampleUtil.verifyTransposition(m, transposed);
+
+ System.out.println("\n>>> Creating matrices to be multiplied.");
+ double[][] data1 = new double[][] {{1, 2}, {3, 4}};
+ double[][] data2 = new double[][] {{5, 6}, {7, 8}};
+
+ Matrix m1 = new MatrixCustomStorage(data1);
+ Matrix m2 = new MatrixCustomStorage(data2);
+ Matrix mult = m1.times(m2);
+
+ System.out.println(">>> First matrix: ");
+ MatrixExampleUtil.print(m1);
+ System.out.println(">>> Second matrix: ");
+ MatrixExampleUtil.print(m2);
+ System.out.println(">>> Matrix product: ");
+ MatrixExampleUtil.print(mult);
+
+ System.out.println("\n>>> Calculating matrices determinants.");
+ double det1 = m1.determinant();
+ double det2 = m2.determinant();
+ double detMult = mult.determinant();
+ boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
+
+ System.out.println(">>> First matrix determinant: [" + det1 + "].");
+ System.out.println(">>> Second matrix determinant: [" + det2 + "].");
+ System.out.println(">>> Matrix product determinant: [" + detMult
+ + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
+
+ assert detMultIsAsExp : "Determinant of product matrix [" + detMult
+ + "] should be equal to product of determinants [" + (det1 * det2) + "].";
+
+ System.out.println("\n>>> Matrix API usage example completed.");
+ }
+
+ /**
+ * Example of vector with custom storage, modeled after
+ * {@link org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix}.
+ */
+ static class MatrixCustomStorage extends AbstractMatrix {
+ /**
+ *
+ */
+ public MatrixCustomStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in a matrix.
+ * @param cols Amount of columns in a matrix.
+ */
+ MatrixCustomStorage(int rows, int cols) {
+ assert rows > 0;
+ assert cols > 0;
+
+ setStorage(new ExampleMatrixStorage(rows, cols));
+ }
+
+ /**
+ * @param mtx Source matrix.
+ */
+ MatrixCustomStorage(double[][] mtx) {
+ assert mtx != null;
+
+ setStorage(new ExampleMatrixStorage(mtx));
+ }
+
+ /**
+ * @param orig original matrix to be copied.
+ */
+ private MatrixCustomStorage(MatrixCustomStorage orig) {
+ assert orig != null;
+
+ setStorage(new ExampleMatrixStorage(orig.rowSize(), orig.columnSize()));
+
+ assign(orig);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix copy() {
+ return new MatrixCustomStorage(this);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Matrix like(int rows, int cols) {
+ return new MatrixCustomStorage(rows, cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public Vector likeVector(int crd) {
+ return new DenseLocalOnHeapVector(crd);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExample.java
new file mode 100644
index 0000000..66f50d5
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExample.java
@@ -0,0 +1,79 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+
+/**
+ * This example shows how to use {@link Matrix} API.
+ */
+public final class MatrixExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Basic Matrix API usage example started.");
+
+ System.out.println("\n>>> Creating a matrix to be transposed.");
+ double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
+ Matrix m = new DenseLocalOnHeapMatrix(data);
+ Matrix transposed = m.transpose();
+
+ System.out.println(">>> Matrix: ");
+ MatrixExampleUtil.print(m);
+ System.out.println(">>> Transposed matrix: ");
+ MatrixExampleUtil.print(transposed);
+
+ MatrixExampleUtil.verifyTransposition(m, transposed);
+
+ System.out.println("\n>>> Creating matrices to be multiplied.");
+ double[][] data1 = new double[][] {{1, 2}, {3, 4}};
+ double[][] data2 = new double[][] {{5, 6}, {7, 8}};
+
+ Matrix m1 = new DenseLocalOnHeapMatrix(data1);
+ Matrix m2 = new DenseLocalOnHeapMatrix(data2);
+ Matrix mult = m1.times(m2);
+
+ System.out.println(">>> First matrix: ");
+ MatrixExampleUtil.print(m1);
+ System.out.println(">>> Second matrix: ");
+ MatrixExampleUtil.print(m2);
+ System.out.println(">>> Matrix product: ");
+ MatrixExampleUtil.print(mult);
+
+ System.out.println("\n>>> Calculating matrices determinants.");
+ double det1 = m1.determinant();
+ double det2 = m2.determinant();
+ double detMult = mult.determinant();
+ boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
+
+ System.out.println(">>> First matrix determinant: [" + det1 + "].");
+ System.out.println(">>> Second matrix determinant: [" + det2 + "].");
+ System.out.println(">>> Matrix product determinant: [" + detMult
+ + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
+
+ assert detMultIsAsExp : "Determinant of product matrix [" + detMult
+ + "] should be equal to product of determinants [" + (det1 * det2) + "].";
+
+ System.out.println("\n>>> Basic Matrix API usage example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExampleUtil.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExampleUtil.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExampleUtil.java
new file mode 100644
index 0000000..bf406a8
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/MatrixExampleUtil.java
@@ -0,0 +1,52 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.Tracer;
+
+/**
+ * Utility functions for {@link Matrix} API examples.
+ */
+class MatrixExampleUtil {
+ /**
+ * Verifies matrix transposition.
+ *
+ * @param m Original matrix.
+ * @param transposed Transposed matrix.
+ */
+ static void verifyTransposition(Matrix m, Matrix transposed) {
+ for (int row = 0; row < m.rowSize(); row++)
+ for (int col = 0; col < m.columnSize(); col++) {
+ double val = m.get(row, col);
+ double valTransposed = transposed.get(col, row);
+
+ assert val == valTransposed : "Values not equal at (" + row + "," + col
+ + "), original: " + val + " transposed: " + valTransposed;
+ }
+ }
+
+ /**
+ * Prints matrix values to console.
+ *
+ * @param m Matrix to print.
+ */
+ static void print(Matrix m) {
+ Tracer.showAscii(m);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/OffHeapMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/OffHeapMatrixExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/OffHeapMatrixExample.java
new file mode 100644
index 0000000..71dc2b8
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/OffHeapMatrixExample.java
@@ -0,0 +1,84 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
+
+/**
+ * This example shows how to use off-heap {@link Matrix} API.
+ */
+public final class OffHeapMatrixExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Off-heap matrix API usage example started.");
+
+ System.out.println("\n>>> Creating a matrix to be transposed.");
+ double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
+ Matrix m = new DenseLocalOffHeapMatrix(data.length, data[0].length);
+ m.assign(data);
+ Matrix transposed = m.transpose();
+
+ System.out.println(">>> Matrix: ");
+ MatrixExampleUtil.print(m);
+ System.out.println(">>> Transposed matrix: ");
+ MatrixExampleUtil.print(transposed);
+
+ MatrixExampleUtil.verifyTransposition(m, transposed);
+
+ System.out.println("\n>>> Creating matrices to be multiplied.");
+ double[][] data1 = new double[][] {{1, 2}, {3, 4}};
+ double[][] data2 = new double[][] {{5, 6}, {7, 8}};
+
+ Matrix m1 = new DenseLocalOffHeapMatrix(data1.length, data1[0].length);
+ Matrix m2 = new DenseLocalOffHeapMatrix(data2.length, data2[0].length);
+
+ m1.assign(data1);
+ m2.assign(data2);
+
+ Matrix mult = m1.times(m2);
+
+ System.out.println(">>> First matrix: ");
+ MatrixExampleUtil.print(m1);
+ System.out.println(">>> Second matrix: ");
+ MatrixExampleUtil.print(m2);
+ System.out.println(">>> Matrix product: ");
+ MatrixExampleUtil.print(mult);
+
+ System.out.println("\n>>> Calculating matrices determinants.");
+ double det1 = m1.determinant();
+ double det2 = m2.determinant();
+ double detMult = mult.determinant();
+ boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
+
+ System.out.println(">>> First matrix determinant: [" + det1 + "].");
+ System.out.println(">>> Second matrix determinant: [" + det2 + "].");
+ System.out.println(">>> Matrix product determinant: [" + detMult
+ + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
+
+ assert detMultIsAsExp : "Determinant of product matrix [" + detMult
+ + "] should be equal to product of determinants [" + (det1 * det2) + "].";
+
+ System.out.println("\n>>> Off-heap matrix API usage example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseDistributedMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseDistributedMatrixExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseDistributedMatrixExample.java
new file mode 100644
index 0000000..ffbd9af
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseDistributedMatrixExample.java
@@ -0,0 +1,65 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.impls.matrix.SparseDistributedMatrix;
+import org.apache.ignite.thread.IgniteThread;
+
+/**
+ * This example shows how to use {@link SparseDistributedMatrix} API.
+ */
+public class SparseDistributedMatrixExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) throws InterruptedException {
+ System.out.println();
+ System.out.println(">>> Sparse distributed matrix API usage example started.");
+ // Start ignite grid.
+ try (Ignite ignite = Ignition.start("examples/config/example-ignite.xml")) {
+ System.out.println(">>> Ignite grid started.");
+ // Create IgniteThread, we must work with SparseDistributedMatrix inside IgniteThread
+ // because we create ignite cache internally.
+ IgniteThread igniteThread = new IgniteThread(ignite.configuration().getIgniteInstanceName(), SparseDistributedMatrixExample.class.getSimpleName(), () -> {
+
+ double[][] testValues = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}};
+
+ System.out.println(">>> Create new SparseDistributedMatrix inside IgniteThread.");
+ // Create SparseDistributedMatrix, new cache will be created automagically.
+ SparseDistributedMatrix distributedMatrix = new SparseDistributedMatrix(testValues.length, testValues[0].length,
+ StorageConstants.ROW_STORAGE_MODE, StorageConstants.RANDOM_ACCESS_MODE);
+
+ distributedMatrix.assign(testValues);
+
+ assert distributedMatrix.sum() == 3.0;
+
+ System.out.println(">>> Destroy SparseDistributedMatrix after using.");
+ // Destroy internal cache.
+ distributedMatrix.destroy();
+ });
+
+ igniteThread.start();
+
+ igniteThread.join();
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseMatrixExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseMatrixExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseMatrixExample.java
new file mode 100644
index 0000000..d63d985
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/SparseMatrixExample.java
@@ -0,0 +1,84 @@
+/*
+ * 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.examples.ml.math.matrix;
+
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrix;
+
+/**
+ * This example shows how to use sparse {@link Matrix} API.
+ */
+public final class SparseMatrixExample {
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) {
+ System.out.println();
+ System.out.println(">>> Sparse matrix API usage example started.");
+
+ System.out.println("\n>>> Creating a matrix to be transposed.");
+ double[][] data = new double[][] {{1, 2, 3}, {4, 5, 6}};
+ Matrix m = new SparseLocalOnHeapMatrix(data.length, data[0].length);
+ m.assign(data);
+ Matrix transposed = m.transpose();
+
+ System.out.println(">>> Matrix: ");
+ MatrixExampleUtil.print(m);
+ System.out.println(">>> Transposed matrix: ");
+ MatrixExampleUtil.print(transposed);
+
+ MatrixExampleUtil.verifyTransposition(m, transposed);
+
+ System.out.println("\n>>> Creating matrices to be multiplied.");
+ double[][] data1 = new double[][] {{1, 2}, {3, 4}};
+ double[][] data2 = new double[][] {{5, 6}, {7, 8}};
+
+ Matrix m1 = new SparseLocalOnHeapMatrix(data1.length, data1[0].length);
+ Matrix m2 = new SparseLocalOnHeapMatrix(data2.length, data2[0].length);
+
+ m1.assign(data1);
+ m2.assign(data2);
+
+ Matrix mult = m1.times(m2);
+
+ System.out.println(">>> First matrix: ");
+ MatrixExampleUtil.print(m1);
+ System.out.println(">>> Second matrix: ");
+ MatrixExampleUtil.print(m2);
+ System.out.println(">>> Matrix product: ");
+ MatrixExampleUtil.print(mult);
+
+ System.out.println("\n>>> Calculating matrices determinants.");
+ double det1 = m1.determinant();
+ double det2 = m2.determinant();
+ double detMult = mult.determinant();
+ boolean detMultIsAsExp = Math.abs(detMult - det1 * det2) < 0.0001d;
+
+ System.out.println(">>> First matrix determinant: [" + det1 + "].");
+ System.out.println(">>> Second matrix determinant: [" + det2 + "].");
+ System.out.println(">>> Matrix product determinant: [" + detMult
+ + "], equals product of two other matrices determinants: [" + detMultIsAsExp + "].");
+
+ assert detMultIsAsExp : "Determinant of product matrix [" + detMult
+ + "] should be equal to product of determinants [" + (det1 * det2) + "].";
+
+ System.out.println("\n>>> Sparse matrix API usage example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/package-info.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/package-info.java
new file mode 100644
index 0000000..354119a
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/matrix/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. -->
+ * Core algebra matrix examples.
+ */
+package org.apache.ignite.examples.ml.math.matrix;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/package-info.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/package-info.java
new file mode 100644
index 0000000..52344bf
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/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. -->
+ * Core algebra examples.
+ */
+package org.apache.ignite.examples.ml.math;
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/TracerExample.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/TracerExample.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/TracerExample.java
new file mode 100644
index 0000000..0bf7743
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/TracerExample.java
@@ -0,0 +1,63 @@
+/*
+ * 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.examples.ml.math.tracer;
+
+import java.awt.Color;
+import java.io.IOException;
+import org.apache.ignite.math.Tracer;
+import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
+
+/**
+ * Example of using {@link Tracer} utility API.
+ */
+public class TracerExample {
+ /**
+ * Double to color mapper example.
+ */
+ private static final Tracer.ColorMapper COLOR_MAPPER = d -> {
+ if (d <= 0.33)
+ return Color.RED;
+ else if (d <= 0.66)
+ return Color.GREEN;
+ else
+ return Color.BLUE;
+ };
+
+ /**
+ * Executes example.
+ *
+ * @param args Command line arguments, none required.
+ */
+ public static void main(String[] args) throws IOException {
+ System.out.println(">>> Tracer utility example started.");
+
+ // Tracer is a simple utility class that allows pretty-printing of matrices/vectors
+ DenseLocalOnHeapMatrix m = new DenseLocalOnHeapMatrix(new double[][] {
+ {1.12345, 2.12345},
+ {3.12345, 4.12345}
+ });
+
+ System.out.println("\n>>> Tracer output to console in ASCII.");
+ Tracer.showAscii(m, "%.3g");
+
+ System.out.println("\n>>> Tracer output to browser in HTML.");
+ Tracer.showHtml(m, COLOR_MAPPER);
+
+ System.out.println("\n>>> Tracer utility example completed.");
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/package-info.java
----------------------------------------------------------------------
diff --git a/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/package-info.java b/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/package-info.java
new file mode 100644
index 0000000..574e598
--- /dev/null
+++ b/examples/src/main/ml/org/apache/ignite/examples/ml/math/tracer/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. -->
+ * Core algebra tracer example.
+ */
+package org.apache.ignite.examples.ml.math.tracer;
[18/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java
deleted file mode 100644
index 0e9b26f..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/CacheVector.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.ValueMapper;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorKeyMapper;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.impls.CacheUtils;
-import org.apache.ignite.math.impls.storage.vector.CacheVectorStorage;
-
-/**
- * Vector based on existing cache and index and value mapping functions.
- */
-public class CacheVector<K, V> extends AbstractVector {
- /**
- *
- */
- public CacheVector() {
- // No-op.
- }
-
- /**
- * Creates new vector over existing cache.
- *
- * @param size
- * @param cache
- * @param keyFunc
- * @param valMapper
- */
- public CacheVector(
- int size,
- IgniteCache<K, V> cache,
- VectorKeyMapper<K> keyFunc,
- ValueMapper<V> valMapper) {
- setStorage(new CacheVectorStorage<>(size, cache, keyFunc, valMapper));
- }
-
- /**
- * @param mapper
- */
- private Vector mapOverCache(IgniteFunction<Double, Double> mapper) {
- CacheVectorStorage<K, V> sto = storage();
-
- CacheUtils.map(sto.cache().getName(), sto.keyMapper(), sto.valueMapper(), mapper);
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public double minValue() {
- CacheVectorStorage<K, V> sto = storage();
-
- return CacheUtils.min(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
- }
-
- /** {@inheritDoc} */
- @Override public double maxValue() {
- CacheVectorStorage<K, V> sto = storage();
-
- return CacheUtils.max(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteDoubleFunction<Double> fun) {
- return mapOverCache(fun::apply);
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
- // TODO: provide cache-optimized implementation.
- return super.map(fun, y); // TODO
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- CacheVectorStorage<K, V> sto = storage();
-
- return CacheUtils.sum(sto.cache().getName(), sto.keyMapper(), sto.valueMapper());
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(double val) {
- return mapOverCache((Double d) -> val);
- }
-
- /** {@inheritDoc} */
- @Override public Vector plus(double x) {
- return mapOverCache((Double d) -> d + x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector divide(double x) {
- return mapOverCache((Double d) -> d / x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- return mapOverCache((Double d) -> d * x);
- }
-
- /**
- *
- *
- */
- @SuppressWarnings({"unchecked"})
- private CacheVectorStorage<K, V> storage() {
- return (CacheVectorStorage<K, V>)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java
deleted file mode 100644
index 0fddfd6..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/ConstantVector.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.storage.vector.ConstantVectorStorage;
-
-/**
- * Constant value, read-only vector.
- */
-public class ConstantVector extends AbstractReadOnlyVector {
- /**
- *
- */
- public ConstantVector() {
- // No-op.
- }
-
- /**
- * @param size
- * @param val
- */
- public ConstantVector(int size, double val) {
- super(new ConstantVectorStorage(size, val));
- }
-
- /**
- *
- *
- */
- private ConstantVectorStorage storage() {
- return (ConstantVectorStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- ConstantVectorStorage sto = storage();
-
- return new ConstantVector(sto.size(), sto.constant());
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- return new ConstantVector(crd, storage().constant());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- ConstantVector that = (ConstantVector)o;
-
- VectorStorage sto = getStorage();
-
- return (sto != null ? sto.equals(that.getStorage()) : that.getStorage() == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java
deleted file mode 100644
index a10fa45..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DelegatingVector.java
+++ /dev/null
@@ -1,391 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Spliterator;
-import java.util.function.IntToDoubleFunction;
-import org.apache.ignite.lang.IgniteUuid;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-
-/**
- * Convenient class that can be used to add decorations to an existing vector. Subclasses
- * can add weights, indices, etc. while maintaining full vector functionality.
- */
-public class DelegatingVector implements Vector {
- /** Delegating vector. */
- private Vector dlg;
-
- /** Meta attribute storage. */
- private Map<String, Object> meta = new HashMap<>();
-
- /** GUID. */
- private IgniteUuid guid = IgniteUuid.randomUuid();
-
- /** */
- public DelegatingVector() {
- // No-op.
- }
-
- /**
- * @param dlg
- */
- public DelegatingVector(Vector dlg) {
- assert dlg != null;
-
- this.dlg = dlg;
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- out.writeObject(dlg);
- out.writeObject(meta);
- out.writeObject(guid);
- }
-
- /** {@inheritDoc} */
- @SuppressWarnings("unchecked")
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- dlg = (Vector)in.readObject();
- meta = (Map<String, Object>)in.readObject();
- guid = (IgniteUuid)in.readObject();
- }
-
- /** {@inheritDoc} */
- @Override public Map<String, Object> getMetaStorage() {
- return meta;
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return dlg.likeMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix toMatrix(boolean rowLike) {
- return dlg.toMatrix(rowLike);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal) {
- return dlg.toMatrixPlusOne(rowLike, zeroVal);
- }
-
- /** {@inheritDoc} */
- @Override public int size() {
- return dlg.size();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDense() {
- return dlg.isDense();
- }
-
- /** {@inheritDoc} */
- @Override public double minValue() {
- return dlg.minValue();
- }
-
- /** {@inheritDoc} */
- @Override public double maxValue() {
- return dlg.maxValue();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isSequentialAccess() {
- return dlg.isSequentialAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isArrayBased() {
- return dlg.isArrayBased();
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- return new DelegatingVector(dlg);
- }
-
- /** {@inheritDoc} */
- @Override public Iterable<Element> all() {
- return dlg.all();
- }
-
- /** {@inheritDoc} */
- @Override public Iterable<Element> nonZeroes() {
- return dlg.nonZeroes();
- }
-
- /** {@inheritDoc} */
- @Override public Vector sort() {
- return dlg.sort();
- }
-
- /** {@inheritDoc} */
- @Override public Spliterator<Double> allSpliterator() {
- return dlg.allSpliterator();
- }
-
- /** {@inheritDoc} */
- @Override public Spliterator<Double> nonZeroSpliterator() {
- return dlg.nonZeroSpliterator();
- }
-
- /** {@inheritDoc} */
- @Override public Element getElement(int idx) {
- return dlg.getElement(idx);
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(double val) {
- return dlg.assign(val);
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(double[] vals) {
- return dlg.assign(vals);
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(Vector vec) {
- return dlg.assign(vec);
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(IntToDoubleFunction fun) {
- return dlg.assign(fun);
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteDoubleFunction<Double> fun) {
- return dlg.map(fun);
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun) {
- return dlg.map(vec, fun);
- }
-
- /** {@inheritDoc} */
- @Override public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y) {
- return dlg.map(fun, y);
- }
-
- /** {@inheritDoc} */
- @Override public Vector divide(double x) {
- return dlg.divide(x);
- }
-
- /** {@inheritDoc} */
- @Override public double dot(Vector vec) {
- return dlg.dot(vec);
- }
-
- /** {@inheritDoc} */
- @Override public double get(int idx) {
- return dlg.get(idx);
- }
-
- /** {@inheritDoc} */
- @Override public double getX(int idx) {
- return dlg.getX(idx);
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- return dlg.like(crd);
- }
-
- /** {@inheritDoc} */
- @Override public Vector minus(Vector vec) {
- return dlg.minus(vec);
- }
-
- /** {@inheritDoc} */
- @Override public Vector normalize() {
- return dlg.normalize();
- }
-
- /** {@inheritDoc} */
- @Override public Vector normalize(double power) {
- return dlg.normalize(power);
- }
-
- /** {@inheritDoc} */
- @Override public Vector logNormalize() {
- return dlg.logNormalize();
- }
-
- /** {@inheritDoc} */
- @Override public Vector logNormalize(double power) {
- return dlg.logNormalize(power);
- }
-
- /** {@inheritDoc} */
- @Override public double kNorm(double power) {
- return dlg.kNorm(power);
- }
-
- /** {@inheritDoc} */
- @Override public Element minElement() {
- return dlg.minElement();
- }
-
- /** {@inheritDoc} */
- @Override public Element maxElement() {
- return dlg.maxElement();
- }
-
- /** {@inheritDoc} */
- @Override public Vector plus(double x) {
- return dlg.plus(x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector plus(Vector vec) {
- return dlg.plus(vec);
- }
-
- /** {@inheritDoc} */
- @Override public Vector set(int idx, double val) {
- return dlg.set(idx, val);
- }
-
- /** {@inheritDoc} */
- @Override public Vector setX(int idx, double val) {
- return dlg.setX(idx, val);
- }
-
- /** {@inheritDoc} */
- @Override public Vector incrementX(int idx, double val) {
- return dlg.incrementX(idx, val);
- }
-
- /** {@inheritDoc} */
- @Override public Vector increment(int idx, double val) {
- return dlg.increment(idx, val);
- }
-
- /** {@inheritDoc} */
- @Override public int nonZeroElements() {
- return dlg.nonZeroElements();
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- return dlg.times(x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(Vector vec) {
- return dlg.times(vec);
- }
-
- /** {@inheritDoc} */
- @Override public Vector viewPart(int off, int len) {
- return dlg.viewPart(off, len);
- }
-
- /** {@inheritDoc} */
- @Override public VectorStorage getStorage() {
- return dlg.getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- return dlg.sum();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix cross(Vector vec) {
- return dlg.cross(vec);
- }
-
- /** {@inheritDoc} */
- @Override public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun,
- T zeroVal) {
- return dlg.foldMap(foldFun, mapFun, zeroVal);
- }
-
- /** {@inheritDoc} */
- @Override public <T> T foldMap(Vector vec, IgniteBiFunction<T, Double, T> foldFun,
- IgniteBiFunction<Double, Double, Double> combFun, T zeroVal) {
- return dlg.foldMap(vec, foldFun, combFun, zeroVal);
- }
-
- /** {@inheritDoc} */
- @Override public double getLengthSquared() {
- return dlg.getLengthSquared();
- }
-
- /** {@inheritDoc} */
- @Override public double getDistanceSquared(Vector vec) {
- return dlg.getDistanceSquared(vec);
- }
-
- /** {@inheritDoc} */
- @Override public boolean isRandomAccess() {
- return dlg.isRandomAccess();
- }
-
- /** {@inheritDoc} */
- @Override public boolean isDistributed() {
- return dlg.isDistributed();
- }
-
- /** {@inheritDoc} */
- @Override public IgniteUuid guid() {
- return guid;
- }
-
- /** {@inheritDoc} */
- @Override public void destroy() {
- dlg.destroy();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + meta.hashCode();
- res = res * 37 + dlg.hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- DelegatingVector that = (DelegatingVector)o;
-
- return meta.equals(that.meta) && dlg.equals(that.dlg);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java
deleted file mode 100644
index 4e7eb21..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOffHeapVector.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.stream.IntStream;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrix;
-import org.apache.ignite.math.impls.storage.vector.DenseLocalOffHeapVectorStorage;
-
-/**
- * Implementation for {@link Vector} assuming dense logic and local offheap JVM storage.
- * It is suitable for data sets where local, non-distributed execution is satisfactory and on-heap JVM storage
- * is not enough to keep the entire data set.
- */
-public class DenseLocalOffHeapVector extends AbstractVector {
- /** */
- public DenseLocalOffHeapVector() {
- // No-op.
- }
-
- /** */
- private void makeOffheapStorage(int size) {
- setStorage(new DenseLocalOffHeapVectorStorage(size));
- }
-
- /**
- * @param arr Array to copy to offheap storage.
- */
- public DenseLocalOffHeapVector(double[] arr) {
- makeOffheapStorage(arr.length);
-
- assign(arr);
- }
-
- /**
- * @param size Vector cardinality.
- */
- public DenseLocalOffHeapVector(int size) {
- makeOffheapStorage(size);
- }
-
- /** {@inheritDoc} */
- @Override public Vector assign(Vector vec) {
- checkCardinality(vec);
-
- IntStream.range(0, size()).parallel().forEach(idx -> set(idx, vec.get(idx)));
-
- return this;
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- if (x == 0.0)
- return like(size()).assign(0);
- else
- return super.times(x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- return new DenseLocalOffHeapVector(crd);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return new DenseLocalOffHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- return o != null && getClass().equals(o.getClass()) && (getStorage().equals(((Vector)o).getStorage()));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java
deleted file mode 100644
index 5827998..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/DenseLocalOnHeapVector.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Map;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.storage.vector.ArrayVectorStorage;
-
-/**
- * Basic implementation for vector.
- * <p>
- * This is a trivial implementation for vector assuming dense logic, local on-heap JVM storage
- * based on {@code double[]} array. It is only suitable for data sets where
- * local, non-distributed execution is satisfactory and on-heap JVM storage is enough
- * to keep the entire data set.
- */
-public class DenseLocalOnHeapVector extends AbstractVector {
- /**
- * @param size Vector cardinality.
- */
- private VectorStorage mkStorage(int size) {
- return new ArrayVectorStorage(size);
- }
-
- /**
- * @param arr Source array.
- * @param cp {@code true} to clone array, reuse it otherwise.
- */
- private VectorStorage mkStorage(double[] arr, boolean cp) {
- assert arr != null;
-
- return new ArrayVectorStorage(cp ? arr.clone() : arr);
- }
-
- /**
- * @param args Parameters for new Vector.
- */
- public DenseLocalOnHeapVector(Map<String, Object> args) {
- assert args != null;
-
- if (args.containsKey("size"))
- setStorage(mkStorage((int)args.get("size")));
- else if (args.containsKey("arr") && args.containsKey("copy"))
- setStorage(mkStorage((double[])args.get("arr"), (boolean)args.get("copy")));
- else
- throw new UnsupportedOperationException("Invalid constructor argument(s).");
- }
-
- /** */
- public DenseLocalOnHeapVector() {
- // No-op.
- }
-
- /**
- * @param size Vector cardinality.
- */
- public DenseLocalOnHeapVector(int size) {
- setStorage(mkStorage(size));
- }
-
- /**
- * @param arr Source array.
- * @param shallowCp {@code true} to use shallow copy.
- */
- public DenseLocalOnHeapVector(double[] arr, boolean shallowCp) {
- setStorage(mkStorage(arr, shallowCp));
- }
-
- /**
- * @param arr Source array.
- */
- public DenseLocalOnHeapVector(double[] arr) {
- this(arr, false);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return new DenseLocalOnHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- return new DenseLocalOnHeapVector(crd);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java
deleted file mode 100644
index 0e7cfad..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/FunctionVector.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Map;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.functions.IntDoubleToVoidFunction;
-import org.apache.ignite.math.impls.storage.vector.FunctionVectorStorage;
-
-/**
- * Implementation of {@link Vector} that maps vector element index to {@link java.util.function} interfaces.
- */
-public class FunctionVector extends AbstractVector {
- /**
- *
- */
- public FunctionVector() {
- // No-op.
- }
-
- /**
- * Creates read-write or read-only function vector.
- *
- * @param size Vector size.
- * @param getFunc Function that returns value corresponding to given element index.
- * @param setFunc Set function. If {@code null} - this will be a read-only vector.
- */
- public FunctionVector(int size, IgniteFunction<Integer, Double> getFunc, IntDoubleToVoidFunction setFunc) {
- setStorage(new FunctionVectorStorage(size, getFunc, setFunc));
- }
-
- /**
- * Creates read-only function vector.
- *
- * @param size Vector size.
- * @param getFunc Function that returns value corresponding to given element index.
- */
- public FunctionVector(int size, IgniteFunction<Integer, Double> getFunc) {
- setStorage(new FunctionVectorStorage(size, getFunc));
- }
-
- /**
- * @param args Arguments for vector constructor.
- */
- public FunctionVector(Map<String, Object> args) {
- assert args != null;
-
- if (args.containsKey("size") && args.containsKey("getFunc") && args.containsKey("setFunc")) {
- @SuppressWarnings("unchecked")
- IgniteFunction<Integer, Double> getFunc = (IgniteFunction<Integer, Double>)args.get("getFunc");
- IntDoubleToVoidFunction setFunc = (IntDoubleToVoidFunction)args.get("setFunc");
- int size = (int)args.get("size");
-
- setStorage(new FunctionVectorStorage(size, getFunc, setFunc));
- }
- else if (args.containsKey("size") && args.containsKey("getFunc")) {
- @SuppressWarnings("unchecked")
- IgniteFunction<Integer, Double> getFunc = (IgniteFunction<Integer, Double>)args.get("getFunc");
- int size = (int)args.get("size");
-
- setStorage(new FunctionVectorStorage(size, getFunc));
- }
- else
- throw new UnsupportedOperationException("Invalid constructor argument(s).");
- }
-
- /**
- *
- *
- */
- private FunctionVectorStorage storage() {
- return (FunctionVectorStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public org.apache.ignite.math.Vector like(int crd) {
- FunctionVectorStorage sto = storage();
-
- return new FunctionVector(crd, sto.getFunction(), sto.setFunction());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- if (x == 0.0)
- return like(size()).assign(0);
- else
- return super.times(x);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java
deleted file mode 100644
index 8f32a89..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/MatrixVectorView.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.impls.storage.vector.MatrixVectorStorage;
-
-/**
- * Row or column vector view off the matrix.
- */
-public class MatrixVectorView extends AbstractVector {
- /** */ private Matrix parent;
-
- /** */ private int row;
- /** */ private int col;
-
- /** */ private int rowStride;
- /** */ private int colStride;
-
- /**
- *
- */
- public MatrixVectorView() {
- // No-op.
- }
-
- /**
- * @param parent
- * @param row
- * @param col
- * @param rowStride
- * @param colStride
- */
- public MatrixVectorView(Matrix parent, int row, int col, int rowStride, int colStride) {
- assert parent != null;
-
- if (row < 0 || row >= parent.rowSize())
- throw new IndexException(row);
- if (col < 0 || col >= parent.columnSize())
- throw new IndexException(col);
-
- this.parent = parent;
-
- this.row = row;
- this.col = col;
-
- this.rowStride = rowStride;
- this.colStride = colStride;
-
- setStorage(new MatrixVectorStorage(parent, row, col, rowStride, colStride));
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- return new MatrixVectorView(parent, row, col, rowStride, colStride);
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- return parent.likeVector(crd);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return parent.like(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeObject(parent);
- out.writeInt(row);
- out.writeInt(col);
- out.writeInt(rowStride);
- out.writeInt(colStride);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- parent = (Matrix)in.readObject();
- row = in.readInt();
- col = in.readInt();
- rowStride = in.readInt();
- colStride = in.readInt();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + (parent == null ? 0 : parent.hashCode());
- res = res * 37 + row;
- res = res * 37 + col;
- res = res * 37 + rowStride;
- res = res * 37 + colStride;
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- MatrixVectorView that = (MatrixVectorView)o;
-
- return (parent != null ? parent.equals(that.parent) : that.parent == null) &&
- row == that.row &&
- col == that.col &&
- rowStride == that.rowStride &&
- colStride == that.colStride;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java
deleted file mode 100644
index cc9e835..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/PivotedVectorView.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.impls.storage.vector.PivotedVectorStorage;
-
-/**
- * Pivoted (index mapped) view over another vector.
- */
-public class PivotedVectorView extends AbstractVector {
- /** */ private Vector vec;
-
- /**
- * @param vec
- * @param pivot Mapping from external index to internal.
- * @param unpivot Mapping from internal index to external.
- */
- public PivotedVectorView(Vector vec, int[] pivot, int[] unpivot) {
- setStorage(new PivotedVectorStorage(vec.getStorage(), pivot, unpivot));
-
- checkCardinality(pivot);
- checkCardinality(unpivot);
-
- this.vec = vec;
- }
-
- /**
- * @param vec
- * @param pivot
- */
- public PivotedVectorView(Vector vec, int[] pivot) {
- setStorage(new PivotedVectorStorage(vec.getStorage(), pivot));
-
- checkCardinality(pivot);
-
- this.vec = vec;
- }
-
- /**
- *
- *
- */
- private PivotedVectorStorage storage() {
- return (PivotedVectorStorage)getStorage();
- }
-
- /**
- *
- */
- public PivotedVectorView() {
- // No-op.
- }
-
- /**
- *
- *
- */
- public Vector getBaseVector() {
- return vec;
- }
-
- /**
- * @param i
- */
- public int pivot(int i) {
- return storage().pivot()[i];
- }
-
- /**
- * @param i
- */
- public int unpivot(int i) {
- return storage().unpivot()[i];
- }
-
- /**
- * @param idx
- */
- protected Vector.Element makeElement(int idx) {
- checkIndex(idx);
-
- // External index.
- int exIdx = storage().pivot()[idx];
-
- return new Vector.Element() {
- /** {@inheritDoc */
- @Override public double get() {
- return storageGet(idx);
- }
-
- /** {@inheritDoc */
- @Override public int index() {
- return exIdx;
- }
-
- /** {@inheritDoc */
- @Override public void set(double val) {
- storageSet(idx, val);
- }
- };
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- PivotedVectorStorage sto = storage();
-
- return new PivotedVectorView(vec, sto.pivot(), sto.unpivot());
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return vec.likeMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- if (x == 0.0)
- return copy().map(Functions.mult(x));
- else
- return super.times(x);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeObject(vec);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- vec = (Vector)in.readObject();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java
deleted file mode 100644
index c9121c9..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/RandomVector.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.util.Map;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.matrix.RandomMatrix;
-import org.apache.ignite.math.impls.storage.vector.RandomVectorStorage;
-
-/**
- * Random vector. Each value is taken from {-1,0,1} with roughly equal probability. Note
- * that by default, the value is determined by a relatively simple hash of the index.
- */
-public class RandomVector extends AbstractReadOnlyVector {
- /** */ private boolean fastHash;
-
- /**
- * @param size Vector cardinality.
- * @param fastHash
- */
- private VectorStorage mkStorage(int size, boolean fastHash) {
- this.fastHash = fastHash;
-
- return new RandomVectorStorage(size, fastHash);
- }
-
- /**
- * @param size
- * @param fastHash
- */
- public RandomVector(int size, boolean fastHash) {
- setStorage(mkStorage(size, fastHash));
- }
-
- /**
- * @param size
- */
- public RandomVector(int size) {
- this(size, true);
- }
-
- /**
- * @param args
- */
- public RandomVector(Map<String, Object> args) {
- assert args != null;
-
- if (args.containsKey("size") && args.containsKey("fastHash"))
- setStorage(mkStorage((int)args.get("size"), (boolean)args.get("fastHash")));
- else if (args.containsKey("size"))
- setStorage(mkStorage((int)args.get("size"), true));
- else
- throw new UnsupportedOperationException("Invalid constructor argument(s).");
- }
-
- /** */
- public RandomVector() {
- // No-op.
- }
-
- /** {@inheritDoc} */
- @Override public org.apache.ignite.math.Vector like(int crd) {
- return new RandomVector(crd, fastHash);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return new RandomMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public void writeExternal(ObjectOutput out) throws IOException {
- super.writeExternal(out);
-
- out.writeBoolean(fastHash);
- }
-
- /** {@inheritDoc} */
- @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
- super.readExternal(in);
-
- fastHash = in.readBoolean();
- }
-
- /** {@inheritDoc} */
- @Override public int hashCode() {
- int res = 1;
-
- res = res * 37 + Boolean.hashCode(fastHash);
- res = res * 37 + getStorage().hashCode();
-
- return res;
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- if (this == o)
- return true;
-
- if (o == null || getClass() != o.getClass())
- return false;
-
- RandomVector that = (RandomVector)o;
- VectorStorage sto = getStorage();
-
- return fastHash == that.fastHash && (sto != null ? sto.equals(that.getStorage()) : that.getStorage() == null);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java
deleted file mode 100644
index 8d19ee0..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVector.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * 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.vector;
-
-import java.util.Map;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.storage.vector.SingleElementVectorStorage;
-
-/**
- * Read-write vector holding a single non-zero value at some index.
- */
-public class SingleElementVector extends AbstractVector {
- /**
- *
- */
- public SingleElementVector() {
- // No-op
- }
-
- /**
- * @param size
- * @param idx
- * @param val
- */
- public SingleElementVector(int size, int idx, double val) {
- super(new SingleElementVectorStorage(size, idx, val));
- }
-
- /**
- * @param args
- */
- public SingleElementVector(Map<String, Object> args) {
- assert args != null;
-
- if (args.containsKey("size") && args.containsKey("index") && args.containsKey("value")) {
- int size = (int)args.get("size");
- int idx = (int)args.get("index");
- double val = (double)args.get("value");
-
- setStorage(new SingleElementVectorStorage(size, idx, val));
- }
- else
- throw new UnsupportedOperationException("Invalid constructor argument(s).");
- }
-
- /**
- *
- *
- */
- private SingleElementVectorStorage storage() {
- return (SingleElementVectorStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Element minElement() {
- return makeElement(storage().index());
- }
-
- /** {@inheritDoc} */
- @Override public Element maxElement() {
- return makeElement(storage().index());
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- return getX(storage().index());
- }
-
- /** {@inheritDoc} */
- @Override public int nonZeroElements() {
- return isZero(get(storage().index())) ? 0 : 1;
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- int idx = storage().index();
-
- return new SingleElementVector(crd, idx, getX(idx));
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java
deleted file mode 100644
index 76a1c0a..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SingleElementVectorView.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.Functions;
-import org.apache.ignite.math.impls.storage.vector.SingleElementVectorDelegateStorage;
-
-/**
- * Single value vector view over another vector.
- */
-public class SingleElementVectorView extends AbstractVector {
- /**
- *
- */
- public SingleElementVectorView() {
- // No-op.
- }
-
- /**
- * @param vec
- * @param idx
- */
- public SingleElementVectorView(Vector vec, int idx) {
- super(new SingleElementVectorDelegateStorage(vec, idx));
- }
-
- /**
- *
- *
- */
- private SingleElementVectorDelegateStorage storage() {
- return (SingleElementVectorDelegateStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Vector.Element minElement() {
- return makeElement(storage().index());
- }
-
- /** {@inheritDoc} */
- @Override public Vector.Element maxElement() {
- return makeElement(storage().index());
- }
-
- /** {@inheritDoc} */
- @Override public double sum() {
- return getX(storage().index());
- }
-
- /** {@inheritDoc} */
- @Override public int nonZeroElements() {
- return isZero(getX(storage().index())) ? 0 : 1;
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- SingleElementVectorDelegateStorage sto = storage();
-
- return new SingleElementVectorView(sto.delegate(), sto.index());
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- if (x == 0.0)
- return copy().map(Functions.mult(x));
- else
- return super.times(x);
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java
deleted file mode 100644
index 2fd1c57..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalOffHeapVector.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.storage.vector.SparseLocalOffHeapVectorStorage;
-
-/**
- * Implementation for {@link Vector} assuming sparse logic and local offheap JVM storage.
- * It is suitable for data sets where local, non-distributed execution is satisfactory and on-heap JVM storage
- * is not enough to keep the entire data set.
- * <p>See also: <a href="https://en.wikipedia.org/wiki/Sparse_array">Wikipedia article</a>.</p>
- */
-public class SparseLocalOffHeapVector extends AbstractVector {
- /**
- * @param crd Vector cardinality.
- */
- public SparseLocalOffHeapVector(int crd) {
- setStorage(new SparseLocalOffHeapVectorStorage(crd));
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- return new SparseLocalOffHeapVector(crd);
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return null;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java
deleted file mode 100644
index ebb6731..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/SparseLocalVector.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * 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.vector;
-
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.StorageConstants;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.storage.vector.SparseLocalOnHeapVectorStorage;
-
-/**
- * Local on-heap sparse vector based on hash map storage.
- */
-public class SparseLocalVector extends AbstractVector implements StorageConstants {
- /**
- *
- */
- public SparseLocalVector() {
- // No-op.
- }
-
- /**
- * @param size
- * @param acsMode
- */
- public SparseLocalVector(int size, int acsMode) {
- assertAccessMode(acsMode);
-
- setStorage(new SparseLocalOnHeapVectorStorage(size, acsMode));
- }
-
- /** */
- private SparseLocalOnHeapVectorStorage storage() {
- return (SparseLocalOnHeapVectorStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- SparseLocalOnHeapVectorStorage sto = storage();
-
- return new SparseLocalVector(crd, sto.getAccessMode());
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- return new SparseLocalOnHeapMatrix(rows, cols);
- }
-
- /** {@inheritDoc} */
- @Override public Vector times(double x) {
- if (x == 0.0)
- return assign(0);
- else
- return super.times(x);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java
deleted file mode 100644
index ce51a45..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/VectorView.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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.vector;
-
-import java.io.Externalizable;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.VectorStorage;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.impls.storage.vector.DelegateVectorStorage;
-
-/**
- * Implements the partial view into the parent {@link Vector}.
- */
-public class VectorView extends AbstractVector {
- /**
- * Constructor for {@link Externalizable} interface.
- */
- public VectorView() {
- // No-op.
- }
-
- /**
- * @param parent Backing parent {@link Vector}.
- * @param off Offset to parent vector.
- * @param len Size of the view.
- */
- public VectorView(Vector parent, int off, int len) {
- super(new DelegateVectorStorage(parent.getStorage(), off, len));
- }
-
- /**
- * @param sto Backing parent {@link VectorStorage}.
- * @param off Offset to parent vector.
- * @param len Size of the view.
- */
- public VectorView(VectorStorage sto, int off, int len) {
- super(new DelegateVectorStorage(sto, off, len));
- }
-
- /** */
- private DelegateVectorStorage storage() {
- return (DelegateVectorStorage)getStorage();
- }
-
- /** {@inheritDoc} */
- @Override public Vector copy() {
- DelegateVectorStorage sto = storage();
-
- return new VectorView(sto.delegate(), sto.offset(), sto.length());
- }
-
- /** {@inheritDoc} */
- @Override public Vector like(int crd) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public Matrix likeMatrix(int rows, int cols) {
- throw new UnsupportedOperationException();
- }
-
- /** {@inheritDoc} */
- @Override public boolean equals(Object o) {
- return this == o ||
- ((o != null)
- && o.getClass() == getClass()
- && (getStorage().equals(((VectorView)o).getStorage())));
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/impls/vector/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/impls/vector/package-info.java
deleted file mode 100644
index d6ca1f3..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/impls/vector/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 specific implementations for vectors.
- */
-package org.apache.ignite.math.impls.vector;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/package-info.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/package-info.java b/modules/math/src/main/java/org/apache/ignite/math/package-info.java
deleted file mode 100644
index 05ce651..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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 main APIs for distributed code algebra.
- */
-package org.apache.ignite.math;
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/resources/org/apache/ignite/math/d3-matrix-template.html
----------------------------------------------------------------------
diff --git a/modules/math/src/main/resources/org/apache/ignite/math/d3-matrix-template.html b/modules/math/src/main/resources/org/apache/ignite/math/d3-matrix-template.html
deleted file mode 100644
index 19a907a..0000000
--- a/modules/math/src/main/resources/org/apache/ignite/math/d3-matrix-template.html
+++ /dev/null
@@ -1,128 +0,0 @@
-<!DOCTYPE html>
-<!--
- 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.
--->
-<meta charset="utf-8">
-<title>IgniteML</title>
-<style>
- body {
- margin: 0 15px;
- }
-
- p {
- margin: 10px 0 !important;
- }
-
- .name {
- font-size: 20px;
- font-weight: 400;
- font-family: monospace;
- }
-
- .swatch {
- display: inline-block;
- width: 25px;
- height: 25px;
- margin-left: 5px;
- vertical-align: bottom;
- }
-</style>
-<body>
-<img style="margin-top: 15px" width="100px" src="https://ignite.apache.org/images/logo3.png">
-<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.min.js"></script>
-<script>
- /*@DATA@*/
- var data = [[{d: 2.256, r: 198, g: 128, b: 128}, {d: 0.123, r: 218, g: 228, b: 18}], [{
- d: 2.256,
- r: 108,
- g: 28,
- b: 108
- }, {d: 0.123, r: 228, g: 228, b: 228}]];
- /*@MAX@*/
- var max = {d: 2.256, r: 128, g: 128, b: 128};
- /*@MIN@*/
- var min = {d: 0.123, r: 228, g: 228, b: 228};
- /*@NAME@*/
- var name = "Matrix";
-
- var rows = data.length;
- var cols = data[0].length;
-
- var range = max.d - min.d;
-
- var rw, rh;
- var W, H;
-
- if (cols > W) {
- rw = 1;
- W = cols;
- }
- else {
- W = 1000;
- rw = Math.min(Math.round(W / cols), 10);
- }
-
- if (rows > H) {
- rh = 1;
- H = rows;
- }
- else {
- H = 1000;
- rh = Math.min(Math.round(H / rows), 10);
- }
-
- d3.selectAll("body")
- .append("p")
- .text(name + " (" + rows + "x" + cols + ")")
- .attr("class", "name");
-
- d3.selectAll("body")
- .append("p")
- .attr("class", "name")
- .text("Max: " + max.d)
- .append("span")
- .attr("class", "swatch")
- .attr("style", "background-color: rgb(" + max.r + ", " + max.g + ", " + max.b + ")");
-
- d3.selectAll("body")
- .append("p")
- .attr("class", "name")
- .text("Min: " + min.d)
- .append("span")
- .attr("class", "swatch")
- .attr("style", "background-color: rgb(" + min.r + ", " + min.g + ", " + min.b + ")");
-
- var svg = d3.select("body").append("svg")
- .attr("width", W)
- .attr("height", H);
-
- var y = 0;
-
- for (var row = 0; row < rows; row++)
- svg.selectAll("div")
- .data(data[row])
- .enter()
- .append("rect")
- .attr("x", function (d, i) {
- return i * rw
- })
- .attr("y", rh * row)
- .attr("fill", function (d) {
- return "rgb(" + d.r + ", " + d.g + ", " + d.b + ")";
- })
- .attr("width", rw)
- .attr("height", rh);
-</script>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/resources/org/apache/ignite/math/d3-vector-template.html
----------------------------------------------------------------------
diff --git a/modules/math/src/main/resources/org/apache/ignite/math/d3-vector-template.html b/modules/math/src/main/resources/org/apache/ignite/math/d3-vector-template.html
deleted file mode 100644
index 7644481..0000000
--- a/modules/math/src/main/resources/org/apache/ignite/math/d3-vector-template.html
+++ /dev/null
@@ -1,111 +0,0 @@
-<!DOCTYPE html>
-<!--
- 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.
--->
-<meta charset="utf-8">
-<title>IgniteML</title>
-<style>
- body {
- margin: 0 15px;
- }
-
- p {
- margin: 10px 0 !important;
- }
-
- .name {
- font-size: 20px;
- font-weight: 400;
- font-family: monospace;
- }
-
- .swatch {
- display: inline-block;
- width: 25px;
- height: 25px;
- margin-left: 5px;
- vertical-align: bottom;
- }
-</style>
-<body>
-<img style="margin-top: 15px" width="100px" src="https://ignite.apache.org/images/logo3.png">
-<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.min.js"></script>
-<script>
- /*@DATA@*/
- var data = [{d: 2.256, r: 128, g: 128, b: 128}, {d: 0.123, r: 228, g: 228, b: 228}];
- /*@MAX@*/
- var max = {d: 2.256, r: 128, g: 128, b: 128};
- /*@MIN@*/
- var min = {d: 0.123, r: 228, g: 228, b: 228};
- /*@NAME@*/
- var name = "Vector";
-
- var W, H = 1000;
-
- var range = max.d - min.d;
-
- var rh = 20; // Constant.
-
- var rw;
-
- if (data.length > W) {
- rw = 1;
- W = data.length;
- }
- else {
- W = 1000;
- rw = Math.min(Math.round(W / data.length), 5);
- }
-
- d3.selectAll("body")
- .append("p")
- .text(name + " (size: " + data.length + ")")
- .attr("class", "name");
-
- d3.selectAll("body")
- .append("p")
- .attr("class", "name")
- .text("Max: " + max.d)
- .append("span")
- .attr("class", "swatch")
- .attr("style", "background-color: rgb(" + max.r + ", " + max.g + ", " + max.b + ")");
-
- d3.selectAll("body")
- .append("p")
- .attr("class", "name")
- .text("Min: " + min.d)
- .append("span")
- .attr("class", "swatch")
- .attr("style", "background-color: rgb(" + min.r + ", " + min.g + ", " + min.b + ")");
-
- var svg = d3.select("body").append("svg")
- .attr("width", W)
- .attr("height", H);
-
- svg.selectAll("rect")
- .data(data)
- .enter()
- .append("rect")
- .attr("x", function (d, i) {
- return i * rw
- })
- .attr("y", 10)
- .attr("fill", function (d) {
- return "rgb(" + d.r + ", " + d.g + ", " + d.b + ")";
- })
- .attr("width", rw)
- .attr("height", rh);
-</script>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/ExternalizeTest.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/ExternalizeTest.java b/modules/math/src/test/java/org/apache/ignite/math/ExternalizeTest.java
deleted file mode 100644
index 218b7ff..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/ExternalizeTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * 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;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import org.apache.ignite.math.impls.MathTestConstants;
-import org.junit.Test;
-
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-/**
- * Common test for externalization.
- */
-public abstract class ExternalizeTest<T extends Externalizable & Destroyable> {
- /** */
- protected void externalizeTest(T initObj) {
- T objRestored = null;
-
- try {
- ByteArrayOutputStream byteArrOutputStream = new ByteArrayOutputStream();
- ObjectOutputStream objOutputStream = new ObjectOutputStream(byteArrOutputStream);
-
- objOutputStream.writeObject(initObj);
-
- ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(byteArrOutputStream.toByteArray());
- ObjectInputStream objInputStream = new ObjectInputStream(byteArrInputStream);
-
- objRestored = (T)objInputStream.readObject();
-
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, initObj.equals(objRestored));
- assertTrue(MathTestConstants.VAL_NOT_EQUALS, Integer.compare(initObj.hashCode(), objRestored.hashCode()) == 0);
- }
- catch (ClassNotFoundException | IOException e) {
- fail(e + " [" + e.getMessage() + "]");
- }
- finally {
- if (objRestored != null)
- objRestored.destroy();
- }
- }
-
- /** */
- @Test
- public abstract void externalizeTest();
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java b/modules/math/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java
deleted file mode 100644
index 318ea95..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/MathImplDistributedTestSuite.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * 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;
-
-import org.apache.ignite.math.impls.matrix.CacheMatrixTest;
-import org.apache.ignite.math.impls.matrix.SparseDistributedMatrixTest;
-import org.apache.ignite.math.impls.storage.matrix.SparseDistributedMatrixStorageTest;
-import org.apache.ignite.math.impls.vector.CacheVectorTest;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-/**
- * Test suite for all distributed tests located in org.apache.ignite.math.impls.* package.
- */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
- CacheVectorTest.class,
- CacheMatrixTest.class,
- SparseDistributedMatrixStorageTest.class,
- SparseDistributedMatrixTest.class,
-})
-public class MathImplDistributedTestSuite {
- // No-op.
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java b/modules/math/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java
deleted file mode 100644
index a652e7f..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/MathImplLocalTestSuite.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * 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;
-
-import org.apache.ignite.math.decompositions.CholeskyDecompositionTest;
-import org.apache.ignite.math.decompositions.EigenDecompositionTest;
-import org.apache.ignite.math.decompositions.LUDecompositionTest;
-import org.apache.ignite.math.decompositions.QRDecompositionTest;
-import org.apache.ignite.math.decompositions.SingularValueDecompositionTest;
-import org.apache.ignite.math.impls.matrix.DenseLocalOffHeapMatrixConstructorTest;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrixConstructorTest;
-import org.apache.ignite.math.impls.matrix.DiagonalMatrixTest;
-import org.apache.ignite.math.impls.matrix.FunctionMatrixConstructorTest;
-import org.apache.ignite.math.impls.matrix.MatrixAttributeTest;
-import org.apache.ignite.math.impls.matrix.MatrixImplementationsTest;
-import org.apache.ignite.math.impls.matrix.MatrixViewConstructorTest;
-import org.apache.ignite.math.impls.matrix.PivotedMatrixViewConstructorTest;
-import org.apache.ignite.math.impls.matrix.RandomMatrixConstructorTest;
-import org.apache.ignite.math.impls.matrix.SparseLocalOnHeapMatrixConstructorTest;
-import org.apache.ignite.math.impls.matrix.TransposedMatrixViewTest;
-import org.apache.ignite.math.impls.storage.matrix.MatrixArrayStorageTest;
-import org.apache.ignite.math.impls.storage.matrix.MatrixOffHeapStorageTest;
-import org.apache.ignite.math.impls.storage.matrix.MatrixStorageImplementationTest;
-import org.apache.ignite.math.impls.storage.vector.RandomAccessSparseVectorStorageTest;
-import org.apache.ignite.math.impls.storage.vector.SparseLocalOffHeapVectorStorageTest;
-import org.apache.ignite.math.impls.storage.vector.VectorArrayStorageTest;
-import org.apache.ignite.math.impls.storage.vector.VectorOffheapStorageTest;
-import org.apache.ignite.math.impls.vector.AbstractVectorTest;
-import org.apache.ignite.math.impls.vector.ConstantVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.DelegatingVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.DenseLocalOffHeapVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.DenseLocalOnHeapVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.FunctionVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.MatrixVectorViewTest;
-import org.apache.ignite.math.impls.vector.PivotedVectorViewConstructorTest;
-import org.apache.ignite.math.impls.vector.RandomVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.SingleElementVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.SingleElementVectorViewConstructorTest;
-import org.apache.ignite.math.impls.vector.SparseLocalVectorConstructorTest;
-import org.apache.ignite.math.impls.vector.VectorAttributesTest;
-import org.apache.ignite.math.impls.vector.VectorFoldMapTest;
-import org.apache.ignite.math.impls.vector.VectorImplementationsTest;
-import org.apache.ignite.math.impls.vector.VectorIterableTest;
-import org.apache.ignite.math.impls.vector.VectorNormTest;
-import org.apache.ignite.math.impls.vector.VectorToMatrixTest;
-import org.apache.ignite.math.impls.vector.VectorViewTest;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-/**
- * Test suite for all local tests located in org.apache.ignite.math.impls.* package.
- */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
- // Vector constructors tests.
- DenseLocalOnHeapVectorConstructorTest.class,
- DenseLocalOffHeapVectorConstructorTest.class,
- SparseLocalVectorConstructorTest.class,
- RandomVectorConstructorTest.class,
- ConstantVectorConstructorTest.class,
- FunctionVectorConstructorTest.class,
- SingleElementVectorConstructorTest.class,
- PivotedVectorViewConstructorTest.class,
- SingleElementVectorViewConstructorTest.class,
- DelegatingVectorConstructorTest.class,
- // Various vectors tests.
- AbstractVectorTest.class,
- VectorImplementationsTest.class,
- VectorViewTest.class,
- MatrixVectorViewTest.class,
- // Vector particular features tests.
- VectorIterableTest.class,
- VectorAttributesTest.class,
- VectorToMatrixTest.class,
- VectorNormTest.class,
- VectorFoldMapTest.class,
- // Vector storage tests
- VectorArrayStorageTest.class,
- VectorOffheapStorageTest.class,
- RandomAccessSparseVectorStorageTest.class,
- SparseLocalOffHeapVectorStorageTest.class,
- // Matrix storage tests.
- MatrixStorageImplementationTest.class,
- MatrixOffHeapStorageTest.class,
- MatrixArrayStorageTest.class,
- // Matrix constructors tests.
- DenseLocalOnHeapMatrixConstructorTest.class,
- DenseLocalOffHeapMatrixConstructorTest.class,
- RandomMatrixConstructorTest.class,
- FunctionMatrixConstructorTest.class,
- MatrixViewConstructorTest.class,
- PivotedMatrixViewConstructorTest.class,
- SparseLocalOnHeapMatrixConstructorTest.class,
- // Matrix tests.
- MatrixImplementationsTest.class,
- DiagonalMatrixTest.class,
- MatrixAttributeTest.class,
- TransposedMatrixViewTest.class,
- // Decomposes
- LUDecompositionTest.class,
- EigenDecompositionTest.class,
- CholeskyDecompositionTest.class,
- QRDecompositionTest.class,
- SingularValueDecompositionTest.class
-})
-public class MathImplLocalTestSuite {
- // No-op.
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/math/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java b/modules/math/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java
deleted file mode 100644
index 44fa8e6..0000000
--- a/modules/math/src/test/java/org/apache/ignite/math/MathImplMainTestSuite.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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;
-
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-/**
- * Test suite for local and distributed tests
- */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
- MathImplLocalTestSuite.class,
- MathImplDistributedTestSuite.class
-})
-public class MathImplMainTestSuite {
- // No-op.
-}
[23/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/Matrix.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/Matrix.java b/modules/math/src/main/java/org/apache/ignite/math/Matrix.java
deleted file mode 100644
index ee7a807..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/Matrix.java
+++ /dev/null
@@ -1,518 +0,0 @@
-/*
- * 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;
-
-import java.io.Externalizable;
-import org.apache.ignite.lang.IgniteUuid;
-import org.apache.ignite.math.exceptions.CardinalityException;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-import org.apache.ignite.math.functions.IgniteFunction;
-import org.apache.ignite.math.functions.IntIntToDoubleFunction;
-
-/**
- * A matrix interface.
- *
- * Based on its flavor it can have vastly different implementations tailored for
- * for different types of data (e.g. dense vs. sparse), different sizes of data or different operation
- * optimizations.
- *
- * Note also that not all operations can be supported by all underlying implementations. If an operation is not
- * supported a {@link UnsupportedOperationException} is thrown. This exception can also be thrown in partial cases
- * where an operation is unsupported only in special cases, e.g. where a given operation cannot be deterministically
- * completed in polynomial time.
- *
- * Based on ideas from <a href="http://mahout.apache.org/">Apache Mahout</a>.
- */
-public interface Matrix extends MetaAttributes, Externalizable, StorageOpsMetrics, Destroyable {
- /**
- * Holder for matrix's element.
- */
- interface Element {
- /**
- * Gets element's value.
- *
- * @return The value of this matrix element.
- */
- double get();
-
- /**
- * Gets element's row index.
- *
- * @return The row index of this element.
- */
- int row();
-
- /**
- * Gets element's column index.
- *
- * @return The column index of this element.
- */
- int column();
-
- /**
- * Sets element's value.
- *
- * @param val Value to set.
- */
- void set(double val);
- }
-
- /**
- * Gets the maximum value in this matrix.
- *
- * @return Maximum value in this matrix.
- */
- public double maxValue();
-
- /**
- * Gets the minimum value in this matrix.
- *
- * @return Minimum value in this matrix.
- */
- public double minValue();
-
- /**
- * Gets the maximum element in this matrix.
- *
- * @return Maximum element in this matrix.
- */
- public Element maxElement();
-
- /**
- * Gets the minimum element in this matrix.
- *
- * @return Minimum element in this matrix.
- */
- public Element minElement();
-
- /**
- * Gets the matrix's element at the given coordinates.
- *
- * @param row Row index.
- * @param col Column index.
- * @return Element at the given coordinates.
- */
- public Element getElement(int row, int col);
-
- /**
- * Swaps two rows in this matrix.
- *
- * @param row1 Row #1.
- * @param row2 Row #2.
- * @return This matrix.
- */
- public Matrix swapRows(int row1, int row2);
-
- /**
- * Swaps two columns in this matrix.
- *
- * @param col1 Column #1.
- * @param col2 Column #2.
- * @return This matrix.
- */
- public Matrix swapColumns(int col1, int col2);
-
- /**
- * Assigns given value to all elements of this matrix.
- *
- * @param val Value to assign to all elements.
- * @return This matrix.
- */
- public Matrix assign(double val);
-
- /**
- * Assigns given values to this matrix.
- *
- * @param vals Values to assign.
- * @return This matrix.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix assign(double[][] vals);
-
- /**
- * Assigns values from given matrix to this matrix.
- *
- * @param mtx Matrix to assign to this matrix.
- * @return This matrix.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix assign(Matrix mtx);
-
- /**
- * Assigns each matrix element to the value generated by given function.
- *
- * @param fun Function that takes the row and column and returns the value to assign.
- * @return This matrix.
- */
- public Matrix assign(IntIntToDoubleFunction fun);
-
- /**
- * Maps all values in this matrix through a given function.
- *
- * @param fun Mapping function.
- * @return This matrix.
- */
- public Matrix map(IgniteDoubleFunction<Double> fun);
-
- /**
- * Maps all values in this matrix through a given function.
- *
- * For this matrix <code>A</code>, argument matrix <code>B</code> and the
- * function <code>F</code> this method maps every cell <code>x, y</code> as:
- * <code>A(x,y) = fun(A(x,y), B(x,y))</code>
- *
- * @param mtx Argument matrix.
- * @param fun Mapping function.
- * @return This function.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix map(Matrix mtx, IgniteBiFunction<Double, Double, Double> fun);
-
- /**
- * Assigns values from given vector to the specified column in this matrix.
- *
- * @param col Column index.
- * @param vec Vector to get values from.
- * @return This matrix.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix assignColumn(int col, Vector vec);
-
- /**
- * Assigns values from given vector to the specified row in this matrix.
- *
- * @param row Row index.
- * @param vec Vector to get values from.
- * @return This matrix.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix assignRow(int row, Vector vec);
-
- /**
- * Collects the results of applying a given function to all rows in this matrix.
- *
- * @param fun Aggregating function.
- * @return Vector of row aggregates.
- */
- public Vector foldRows(IgniteFunction<Vector, Double> fun);
-
- /**
- * Collects the results of applying a given function to all columns in this matrix.
- *
- * @param fun Aggregating function.
- * @return Vector of column aggregates.
- */
- public Vector foldColumns(IgniteFunction<Vector, Double> fun);
-
- /**
- * Folds this matrix into a single value.
- *
- * @param foldFun Folding function that takes two parameters: accumulator and the current value.
- * @param mapFun Mapping function that is called on each matrix cell before its passed to the accumulator (as its
- * second parameter).
- * @param <T> Type of the folded value.
- * @param zeroVal Zero value for fold function.
- * @return Folded value of this matrix.
- */
- public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun, T zeroVal);
-
- /**
- * Calculates the density of the matrix based on supplied criteria.
- * Returns {@code true} if this matrix is denser than threshold with at least 80% confidence.
- *
- * @param threshold the threshold value [0, 1] of non-zero elements above which the matrix is considered dense.
- */
- public boolean density(double threshold);
-
- /**
- * Gets number of columns in this matrix.
- *
- * @return The number of columns in this matrix.
- */
- public int columnSize();
-
- /**
- * Gets number of rows in this matrix.
- *
- * @return The number of rows in this matrix.
- */
- public int rowSize();
-
- /**
- * Returns matrix determinant using Laplace theorem.
- *
- * @return A determinant for this matrix.
- * @throws CardinalityException Thrown if matrix is not square.
- */
- public double determinant();
-
- /**
- * Returns the inverse matrix of this matrix
- *
- * @return Inverse of this matrix
- */
- public Matrix inverse();
-
- /**
- * Divides each value in this matrix by the argument.
- *
- * @param x Divider value.
- * @return This matrix.
- */
- public Matrix divide(double x);
-
- /**
- * Gets the matrix value at the provided location.
- *
- * @param row Row index.
- * @param col Column index.
- * @return Matrix value.
- * @throws IndexException Thrown in case of index is out of bound.
- */
- public double get(int row, int col);
-
- /**
- * Gets the matrix value at the provided location without checking boundaries.
- * This method is marginally quicker than its {@link #get(int, int)} sibling.
- *
- * @param row Row index.
- * @param col Column index.
- * @return Matrix value.
- */
- public double getX(int row, int col);
-
- /**
- * Gets matrix storage model.
- */
- public MatrixStorage getStorage();
-
- /**
- * Clones this matrix.
- *
- * NOTE: new matrix will have the same flavor as the this matrix but a different ID.
- *
- * @return New matrix of the same underlying class, the same size and the same values.
- */
- public Matrix copy();
-
- /**
- * Creates new empty matrix of the same underlying class but of different size.
- *
- * NOTE: new matrix will have the same flavor as the this matrix but a different ID.
- *
- * @param rows Number of rows for new matrix.
- * @param cols Number of columns for new matrix.
- * @return New matrix of the same underlying class and size.
- */
- public Matrix like(int rows, int cols);
-
- /**
- * Creates new empty vector of compatible properties (similar or the same flavor) to this matrix.
- *
- * @param crd Cardinality of the vector.
- * @return Newly created empty vector "compatible" to this matrix.
- */
- public Vector likeVector(int crd);
-
- /**
- * Creates new matrix where each value is a difference between corresponding value of this matrix and
- * passed in argument matrix.
- *
- * @param mtx Argument matrix.
- * @return New matrix of the same underlying class and size.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix minus(Matrix mtx);
-
- /**
- * Creates new matrix where each value is a sum of the corresponding value of this matrix and
- * argument value.
- *
- * @param x Value to add.
- * @return New matrix of the same underlying class and size.
- */
- public Matrix plus(double x);
-
- /**
- * Creates new matrix where each value is a sum of corresponding values of this matrix and
- * passed in argument matrix.
- *
- * @param mtx Argument matrix.
- * @return New matrix of the same underlying class and size.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix plus(Matrix mtx);
-
- /**
- * Auto-generated globally unique matrix ID.
- *
- * @return Matrix GUID.
- */
- public IgniteUuid guid();
-
- /**
- * Sets given value.
- *
- * @param row Row index.
- * @param col Column index.
- * @param val Value to set.
- * @return This matrix.
- * @throws IndexException Thrown in case of either index is out of bound.
- */
- public Matrix set(int row, int col, double val);
-
- /**
- * Sets values for given row.
- *
- * @param row Row index.
- * @param data Row data to set.
- * @return This matrix.
- * @throws IndexException Thrown in case of index is out of bound.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix setRow(int row, double[] data);
-
- /**
- * Sets values for given column.
- *
- * @param col Column index.
- * @param data Column data to set.
- * @return This matrix.
- * @throws IndexException Thrown in case of index is out of bound.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix setColumn(int col, double[] data);
-
- /**
- * Sets given value without checking for index bounds. This method is marginally faster
- * than its {@link #set(int, int, double)} sibling.
- *
- * @param row Row index.
- * @param col Column index.
- * @param val Value to set.
- * @return This matrix.
- */
- public Matrix setX(int row, int col, double val);
-
- /**
- * Creates new matrix containing the product of given value and values in this matrix.
- *
- * @param x Value to multiply.
- * @return New matrix.
- */
- public Matrix times(double x);
-
- /**
- * Creates new matrix that is the product of multiplying this matrix and the argument matrix.
- *
- * @param mtx Argument matrix.
- * @return New matrix.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Matrix times(Matrix mtx);
-
- /**
- * Creates new matrix that is the product of multiplying this matrix and the argument vector.
- *
- * @param vec Argument vector.
- * @return New matrix.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector times(Vector vec);
-
- /**
- * Gets maximum absolute row sum norm of this matrix.
- * See http://mathworld.wolfram.com/MaximumAbsoluteRowSumNorm.html
- *
- * @return Maximum absolute row sum norm of this matrix.
- */
- public double maxAbsRowSumNorm();
-
- /**
- * Gets sum of all elements in the matrix.
- *
- * @return Sum of all elements in this matrix.
- */
- public double sum();
-
- /**
- * Creates new matrix that is transpose of this matrix.
- *
- * @return New transposed matrix.
- */
- public Matrix transpose();
-
- /**
- * Creates new view into this matrix. Changes to the view will be propagated to this matrix.
- *
- * @param off View offset as <code>int[x,y]</code>.
- * @param size View size as <code>int[rows, cols]</code>
- * @return New view.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- * @throws IndexException Thrown in case of offset is out of bound.
- */
- public Matrix viewPart(int[] off, int[] size);
-
- /**
- * Creates new view into this matrix. Changes to the view will be propagated to this matrix.
- *
- * @param rowOff
- * @param rows
- * @param colOff
- * @param cols
- * @return New view.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- * @throws IndexException Thrown in case of offset is out of bound.
- */
- public Matrix viewPart(int rowOff, int rows, int colOff, int cols);
-
- /**
- * Creates new view into matrix row. Changes to the view will be propagated to this matrix.
- *
- * @param row Row index.
- * @return New view.
- * @throws IndexException Thrown in case of index is out of bound.
- */
- public Vector viewRow(int row);
-
- /**
- * Creates new view into matrix column . Changes to the view will be propagated to this matrix.
- *
- * @param col Column index.
- * @return New view.
- * @throws IndexException Thrown in case of index is out of bound.
- */
- public Vector viewColumn(int col);
-
- /**
- * Creates new view into matrix diagonal. Changes to the view will be propagated to this matrix.
- *
- * @return New view.
- */
- public Vector viewDiagonal();
-
- /**
- * Destroys matrix if managed outside of JVM. It's a no-op in all other cases.
- */
- public default void destroy() {
- // No-op.
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java b/modules/math/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java
deleted file mode 100644
index d6ae06f..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/MatrixKeyMapper.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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;
-
-/**
- * Maps {@link Matrix} row and column index to cache key.
- */
-public interface MatrixKeyMapper<K> extends KeyMapper<K> {
- /**
- * @param x Matrix row index.
- * @param y Matrix column index.
- * @return Cache key for given row and column.
- */
- public K apply(int x, int y);
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/MatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/MatrixStorage.java b/modules/math/src/main/java/org/apache/ignite/math/MatrixStorage.java
deleted file mode 100644
index 11eced7..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/MatrixStorage.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * 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;
-
-import java.io.Externalizable;
-
-/**
- * Data storage support for {@link Matrix}.
- */
-public interface MatrixStorage extends Externalizable, StorageOpsMetrics, Destroyable {
- /**
- * @param x Matrix row index.
- * @param y Matrix column index.
- * @return Value corresponding to given row and column.
- */
- public double get(int x, int y);
-
- /**
- * @param x Matrix row index.
- * @param y Matrix column index.
- * @param v Value to set at given row and column.
- */
- public void set(int x, int y, double v);
-
- /**
- *
- */
- public int columnSize();
-
- /**
- *
- */
- public int rowSize();
-
- /**
- * Gets underlying array if {@link StorageOpsMetrics#isArrayBased()} returns {@code true}.
- *
- * @see StorageOpsMetrics#isArrayBased()
- */
- default public double[][] data() {
- return null;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/MetaAttributes.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/MetaAttributes.java b/modules/math/src/main/java/org/apache/ignite/math/MetaAttributes.java
deleted file mode 100644
index 8973b55..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/MetaAttributes.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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;
-
-import java.util.Map;
-
-/**
- * Interface provides support for meta attributes on vectors and matrices.
- */
-public interface MetaAttributes {
- /**
- * Implementation should return an instance of the map to store meta attributes.
- */
- public Map<String, Object> getMetaStorage();
-
- /**
- * Gets meta attribute with given name.
- *
- * @param name Name of the vector meta attribute to get.
- * @param <T> Attribute's type.
- */
- @SuppressWarnings("unchecked")
- public default <T> T getAttribute(String name) {
- return (T)getMetaStorage().get(name);
- }
-
- /**
- * Sets meta attribute with given name and value.
- *
- * @param name Name of the meta attribute.
- * @param val Attribute value.
- * @param <T> Attribute's type.
- */
- public default <T> void setAttribute(String name, T val) {
- getMetaStorage().put(name, val);
- }
-
- /**
- * Removes meta attribute with given name.
- *
- * @param name Name of the meta attribute.
- * @return {@code true} if attribute was present and was removed, {@code false} otherwise.
- */
- public default boolean removeAttribute(String name) {
- boolean is = getMetaStorage().containsKey(name);
-
- if (is)
- getMetaStorage().remove(name);
-
- return is;
- }
-
- /**
- * Checks if given meta attribute is present.
- *
- * @param name Attribute name to check.
- */
- public default boolean hasAttribute(String name) {
- return getMetaStorage().containsKey(name);
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/MurmurHash.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/MurmurHash.java b/modules/math/src/main/java/org/apache/ignite/math/MurmurHash.java
deleted file mode 100644
index 3d1252e..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/MurmurHash.java
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * 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;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-/**
- * This is a very fast, non-cryptographic hash suitable for general hash-based lookup.
- *
- * See http://murmurhash.googlepages.com/ for mre details.
- */
-public class MurmurHash {
- /** Hide it. */
- private MurmurHash() {
- }
-
- /**
- * This produces exactly the same hash values as the final C+ version of MurmurHash3 and is
- * thus suitable for producing the same hash values across platforms.
- *
- * The 32 bit x86 version of this hash should be the fastest variant for relatively short keys like IDs.
- *
- * Note - The x86 and x64 versions do _not_ produce the same results, as the algorithms are
- * optimized for their respective platforms.
- *
- * See also http://github.com/yonik/java_util for future updates to this method.
- *
- * @param data
- * @param off
- * @param len
- * @param seed
- * @return 32 bit hash platform compatible with C++ MurmurHash3 implementation on x86.
- */
- public static int hash3X86(byte[] data, int off, int len, int seed) {
- int c1 = 0xcc9e2d51;
- int c2 = 0x1b873593;
-
- int h1 = seed;
- int roundedEnd = off + (len & 0xfffffffc); // Round down to 4 byte block.
-
- for (int i = off; i < roundedEnd; i += 4) {
- int k1 = (data[i] & 0xff) | ((data[i + 1] & 0xff) << 8) | ((data[i + 2] & 0xff) << 16) | (data[i + 3] << 24);
-
- k1 *= c1;
- k1 = (k1 << 15) | (k1 >>> 17);
- k1 *= c2;
-
- h1 ^= k1;
- h1 = (h1 << 13) | (h1 >>> 19);
- h1 = h1 * 5 + 0xe6546b64;
- }
-
- // Tail.
- int k1 = 0;
-
- switch (len & 0x03) {
- case 3:
- k1 = (data[roundedEnd + 2] & 0xff) << 16;
- // Fallthrough - WTF?
- case 2:
- k1 |= (data[roundedEnd + 1] & 0xff) << 8;
- // Fallthrough - WTF?
- case 1:
- k1 |= data[roundedEnd] & 0xff;
- k1 *= c1;
- k1 = (k1 << 15) | (k1 >>> 17);
- k1 *= c2;
- h1 ^= k1;
- default:
- }
-
- // Finalization.
- h1 ^= len;
-
- h1 ^= h1 >>> 16;
- h1 *= 0x85ebca6b;
- h1 ^= h1 >>> 13;
- h1 *= 0xc2b2ae35;
- h1 ^= h1 >>> 16;
-
- return h1;
- }
-
- /**
- * Hashes an int.
- *
- * @param data The int to hash.
- * @param seed The seed for the hash.
- * @return The 32 bit hash of the bytes in question.
- */
- public static int hash(int data, int seed) {
- byte[] arr = new byte[] {
- (byte)(data >>> 24),
- (byte)(data >>> 16),
- (byte)(data >>> 8),
- (byte)data
- };
-
- return hash(ByteBuffer.wrap(arr), seed);
- }
-
- /**
- * Hashes bytes in an array.
- *
- * @param data The bytes to hash.
- * @param seed The seed for the hash.
- * @return The 32 bit hash of the bytes in question.
- */
- public static int hash(byte[] data, int seed) {
- return hash(ByteBuffer.wrap(data), seed);
- }
-
- /**
- * Hashes bytes in part of an array.
- *
- * @param data The data to hash.
- * @param off Where to start munging.
- * @param len How many bytes to process.
- * @param seed The seed to start with.
- * @return The 32-bit hash of the data in question.
- */
- public static int hash(byte[] data, int off, int len, int seed) {
- return hash(ByteBuffer.wrap(data, off, len), seed);
- }
-
- /**
- * Hashes the bytes in a buffer from the current position to the limit.
- *
- * @param buf The bytes to hash.
- * @param seed The seed for the hash.
- * @return The 32 bit murmur hash of the bytes in the buffer.
- */
- public static int hash(ByteBuffer buf, int seed) {
- ByteOrder byteOrder = buf.order();
- buf.order(ByteOrder.LITTLE_ENDIAN);
-
- int m = 0x5bd1e995;
- int r = 24;
-
- int h = seed ^ buf.remaining();
-
- while (buf.remaining() >= 4) {
- int k = buf.getInt();
-
- k *= m;
- k ^= k >>> r;
- k *= m;
-
- h *= m;
- h ^= k;
- }
-
- if (buf.remaining() > 0) {
- ByteBuffer finish = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN);
-
- finish.put(buf).rewind();
-
- h ^= finish.getInt();
- h *= m;
- }
-
- h ^= h >>> 13;
- h *= m;
- h ^= h >>> 15;
-
- buf.order(byteOrder);
-
- return h;
- }
-
- /**
- * @param data
- * @param seed
- */
- public static long hash64A(byte[] data, int seed) {
- return hash64A(ByteBuffer.wrap(data), seed);
- }
-
- /**
- * @param data
- * @param off
- * @param len
- * @param seed
- */
- public static long hash64A(byte[] data, int off, int len, int seed) {
- return hash64A(ByteBuffer.wrap(data, off, len), seed);
- }
-
- /**
- * @param buf
- * @param seed
- */
- public static long hash64A(ByteBuffer buf, int seed) {
- ByteOrder byteOrder = buf.order();
- buf.order(ByteOrder.LITTLE_ENDIAN);
-
- long m = 0xc6a4a7935bd1e995L;
- int r = 47;
-
- long h = seed ^ (buf.remaining() * m);
-
- while (buf.remaining() >= 8) {
- long k = buf.getLong();
-
- k *= m;
- k ^= k >>> r;
- k *= m;
-
- h ^= k;
- h *= m;
- }
-
- if (buf.remaining() > 0) {
- ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
-
- finish.put(buf).rewind();
-
- h ^= finish.getLong();
- h *= m;
- }
-
- h ^= h >>> r;
- h *= m;
- h ^= h >>> r;
-
- buf.order(byteOrder);
-
- return h;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/StorageConstants.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/StorageConstants.java b/modules/math/src/main/java/org/apache/ignite/math/StorageConstants.java
deleted file mode 100644
index e8bfdf6..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/StorageConstants.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * 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;
-
-/**
- * Support for different modes of accessing data storage.
- */
-public interface StorageConstants {
- /** Storage mode optimized for sequential access. */
- public static final int SEQUENTIAL_ACCESS_MODE = 1001;
-
- /** Storage mode optimized for random access. */
- public static final int RANDOM_ACCESS_MODE = 1002;
-
- /** Storage mode optimized for row access. */
- public static final int ROW_STORAGE_MODE = 2001;
-
- /** Storage mode optimized for column access. */
- public static final int COLUMN_STORAGE_MODE = 2002;
-
- /**
- * @param mode Access mode to verify.
- */
- public default void assertAccessMode(int mode) {
- assert mode == SEQUENTIAL_ACCESS_MODE || mode == RANDOM_ACCESS_MODE;
- }
-
- /**
- * @param mode Storage mode to verify.
- */
- public default void assertStorageMode(int mode) {
- assert mode == ROW_STORAGE_MODE || mode == COLUMN_STORAGE_MODE;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java b/modules/math/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java
deleted file mode 100644
index c3252ba..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/StorageOpsMetrics.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * 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;
-
-/**
- * Storage and operation cost characteristics.
- */
-public interface StorageOpsMetrics {
- /**
- * Checks if this implementation should be considered to be iterable in index order in an efficient way.
- */
- public boolean isSequentialAccess();
-
- /**
- * Checks if this implementation is optimized for random access.
- */
- public boolean isRandomAccess();
-
- /**
- * Checks if this implementation should be considered dense so that it explicitly
- * represents every value.
- */
- public boolean isDense();
-
- /**
- * Checks if implementation is based on Java arrays.
- */
- public boolean isArrayBased();
-
- /**
- * Checks whether implementation is JVM-local or distributed (multi-JVM).
- */
- public boolean isDistributed();
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/Tracer.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/Tracer.java b/modules/math/src/main/java/org/apache/ignite/math/Tracer.java
deleted file mode 100644
index 89d4669..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/Tracer.java
+++ /dev/null
@@ -1,456 +0,0 @@
-/*
- * 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;
-
-import java.awt.Color;
-import java.awt.Desktop;
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
-import java.util.Locale;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import org.apache.ignite.IgniteLogger;
-import org.apache.ignite.lang.IgniteUuid;
-
-/**
- * Utility methods to support output of {@link Vector} and {@link Matrix} instances to plain text or HTML.
- */
-public class Tracer {
- /**
- * Double to color mapper.
- */
- public interface ColorMapper extends Function<Double, Color> {
- }
-
- /** Continuous red-to-blue color mapping. */
- static private ColorMapper defaultColorMapper(double min, double max) {
- double range = max - min;
-
- return new ColorMapper() {
- /** {@inheritDoc} */
- @Override public Color apply(Double d) {
- int r = (int)Math.round(255 * d);
- int g = 0;
- int b = (int)Math.round(255 * (1 - d));
-
- return new Color(r, g, b);
- }
- };
- }
-
- /**
- * Default vector color mapper implementation that map given double value
- * to continuous red-blue (R_B) specter.
- *
- * @param vec Vector to map.
- * @return {@link ColorMapper} for the given vector.
- */
- static private ColorMapper mkVectorColorMapper(Vector vec) {
- return defaultColorMapper(vec.minValue(), vec.maxValue());
- }
-
- /** Default matrix color mapper implementation that map given double value
- * to continuous red-blue (R_B) specter.
- * @param mtx Matrix to be mapped.
- * @return Color mapper for given matrix.
- */
- static private ColorMapper mkMatrixColorMapper(Matrix mtx) {
- return defaultColorMapper(mtx.minValue(), mtx.maxValue());
- }
-
- /**
- * @param vec Vector to show.
- * @param log {@link IgniteLogger} instance for output.
- * @param fmt Format string for vector elements.
- */
- public static void showAscii(Vector vec, IgniteLogger log, String fmt) {
- String cls = vec.getClass().getSimpleName();
-
- log.info(String.format("%s(%d) [%s]", cls, vec.size(), mkString(vec, fmt)));
- }
-
- /**
- * @param vec Vector to show as plain text.
- * @param log {@link IgniteLogger} instance for output.
- */
- public static void showAscii(Vector vec, IgniteLogger log) {
- showAscii(vec, log, "%4f");
- }
-
- /**
- * @param vec Vector to show as plain text.
- * @param fmt Format string for vector elements.
- */
- public static void showAscii(Vector vec, String fmt) {
- String cls = vec.getClass().getSimpleName();
-
- System.out.println(String.format("%s(%d) [%s]", cls, vec.size(), mkString(vec, fmt)));
- }
-
- /**
- * @param mtx Matrix to show as plain text.
- */
- public static void showAscii(Matrix mtx) {
- showAscii(mtx, "%4f");
- }
-
- /**
- * @param mtx Matrix to show.
- * @param row Matrix row to output.
- * @param fmt Format string for matrix elements in the row.
- * @return String representation of given matrix row according to given format.
- */
- static private String rowStr(Matrix mtx, int row, String fmt) {
- StringBuilder buf = new StringBuilder();
-
- boolean first = true;
-
- int cols = mtx.columnSize();
-
- for (int col = 0; col < cols; col++) {
- String s = String.format(fmt, mtx.get(row, col));
-
- if (!first)
- buf.append(", ");
-
- buf.append(s);
-
- first = false;
- }
-
- return buf.toString();
- }
-
- /**
- * @param mtx {@link Matrix} object to show as a plain text.
- * @param fmt Format string for matrix rows.
- */
- public static void showAscii(Matrix mtx, String fmt) {
- String cls = mtx.getClass().getSimpleName();
-
- int rows = mtx.rowSize();
- int cols = mtx.columnSize();
-
- System.out.println(String.format("%s(%dx%d)", cls, rows, cols));
-
- for (int row = 0; row < rows; row++)
- System.out.println(rowStr(mtx, row, fmt));
- }
-
- /**
- * @param mtx {@link Matrix} object to show as a plain text.
- * @param log {@link IgniteLogger} instance to output the logged matrix.
- * @param fmt Format string for matrix rows.
- */
- public static void showAscii(Matrix mtx, IgniteLogger log, String fmt) {
- String cls = mtx.getClass().getSimpleName();
-
- int rows = mtx.rowSize();
- int cols = mtx.columnSize();
-
- log.info(String.format("%s(%dx%d)", cls, rows, cols));
-
- for (int row = 0; row < rows; row++)
- log.info(rowStr(mtx, row, fmt));
- }
-
- /**
- * @param vec {@link Vector} object to show as a plain text.
- */
- public static void showAscii(Vector vec) {
- showAscii(vec, "%4f");
- }
-
- /**
- * Saves given vector as CSV file.
- *
- * @param vec Vector to save.
- * @param fmt Format to use.
- * @param filePath Path of the file to save to.
- */
- public static void saveAsCsv(Vector vec, String fmt, String filePath) throws IOException {
- String s = mkString(vec, fmt);
-
- Files.write(Paths.get(filePath), s.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
- }
-
- /**
- * Saves given matrix as CSV file.
- *
- * @param mtx Matrix to save.
- * @param fmt Format to use.
- * @param filePath Path of the file to save to.
- */
- public static void saveAsCsv(Matrix mtx, String fmt, String filePath) throws IOException {
- String s = mkString(mtx, fmt);
-
- Files.write(Paths.get(filePath), s.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.WRITE);
- }
-
- /**
- * Shows given matrix in the browser with D3-based visualization.
- *
- * @param mtx Matrix to show.
- * @throws IOException Thrown in case of any errors.
- */
- public static void showHtml(Matrix mtx) throws IOException {
- showHtml(mtx, mkMatrixColorMapper(mtx));
- }
-
- /**
- * Shows given matrix in the browser with D3-based visualization.
- *
- * @param mtx Matrix to show.
- * @param cm Optional color mapper. If not provided - red-to-blue (R_B) mapper will be used.
- * @throws IOException Thrown in case of any errors.
- */
- public static void showHtml(Matrix mtx, ColorMapper cm) throws IOException {
- // Read it every time so that we can change it at runtime.
- String tmpl = fileToString("d3-matrix-template.html");
-
- String cls = mtx.getClass().getSimpleName();
-
- double min = mtx.minValue();
- double max = mtx.maxValue();
-
- openHtmlFile(tmpl.
- replaceAll("/\\*@NAME@\\*/.*\n", "var name = \"" + cls + "\";\n").
- replaceAll("/\\*@MIN@\\*/.*\n", "var min = " + dataColorJson(min, cm.apply(min)) + ";\n").
- replaceAll("/\\*@MAX@\\*/.*\n", "var max = " + dataColorJson(max, cm.apply(max)) + ";\n").
- replaceAll("/\\*@DATA@\\*/.*\n", "var data = " + mkJsArrayString(mtx, cm) + ";\n")
- );
- }
-
- /**
- * Shows given vector in the browser with D3-based visualization.
- *
- * @param vec Vector to show.
- * @throws IOException Thrown in case of any errors.
- */
- public static void showHtml(Vector vec) throws IOException {
- showHtml(vec, mkVectorColorMapper(vec));
- }
-
- /**
- * @param d Value of {@link Matrix} or {@link Vector} element.
- * @param clr {@link Color} to paint.
- * @return JSON representation for given value and color.
- */
- static private String dataColorJson(double d, Color clr) {
- return "{" +
- "d: " + String.format("%4f", d) +
- ", r: " + clr.getRed() +
- ", g: " + clr.getGreen() +
- ", b: " + clr.getBlue() +
- "}";
- }
-
- /**
- * Shows given vector in the browser with D3-based visualization.
- *
- * @param vec Vector to show.
- * @param cm Optional color mapper. If not provided - red-to-blue (R_B) mapper will be used.
- * @throws IOException Thrown in case of any errors.
- */
- public static void showHtml(Vector vec, ColorMapper cm) throws IOException {
- // Read it every time so that we can change it at runtime.
- String tmpl = fileToString("d3-vector-template.html");
-
- String cls = vec.getClass().getSimpleName();
-
- double min = vec.minValue();
- double max = vec.maxValue();
-
- openHtmlFile(tmpl.
- replaceAll("/\\*@NAME@\\*/.*\n", "var name = \"" + cls + "\";\n").
- replaceAll("/\\*@MIN@\\*/.*\n", "var min = " + dataColorJson(min, cm.apply(min)) + ";\n").
- replaceAll("/\\*@MAX@\\*/.*\n", "var max = " + dataColorJson(max, cm.apply(max)) + ";\n").
- replaceAll("/\\*@DATA@\\*/.*\n", "var data = " + mkJsArrayString(vec, cm) + ";\n")
- );
- }
-
- /**
- * Reads file content into the string.
- *
- * @param fileName Name of the file (on classpath) to read.
- * @return Content of the file.
- * @throws IOException If an I/O error of some sort has occurred.
- */
- private static String fileToString(String fileName) throws IOException {
- assert Tracer.class.getResourceAsStream(fileName) != null : "Can't get resource: " + fileName;
-
- InputStreamReader is = new InputStreamReader(Tracer.class.getResourceAsStream(fileName));
-
- String str = new BufferedReader(is).lines().collect(Collectors.joining("\n"));
-
- is.close();
-
- return str;
- }
-
- /**
- * Opens file in the browser with given HTML content.
- *
- * @param html HTML content.
- * @throws IOException Thrown in case of any errors.
- */
- static private void openHtmlFile(String html) throws IOException {
- File temp = File.createTempFile(IgniteUuid.randomUuid().toString(), ".html");
-
- BufferedWriter bw = new BufferedWriter(new FileWriter(temp));
-
- bw.write(html);
-
- bw.close();
-
- Desktop.getDesktop().browse(temp.toURI());
- }
-
- /**
- * Gets string presentation of this vector.
- *
- * @param vec Vector to string-ify.
- * @param fmt {@link String#format(Locale, String, Object...)} format.
- */
- private static String mkString(Vector vec, String fmt) {
- boolean first = true;
-
- StringBuilder buf = new StringBuilder();
-
- for (Vector.Element x : vec.all()) {
- String s = String.format(Locale.US, fmt, x.get());
-
- if (!first) {
- buf.append(", ");
- buf.append(s);
- }
- else {
- buf.append(s);
- first = false;
- }
- }
-
- return buf.toString();
- }
-
- /**
- * Gets JavaScript array presentation of this vector.
- *
- * @param vec Vector to JavaScript-ify.
- * @param cm Color mapper to user.
- */
- private static String mkJsArrayString(Vector vec, ColorMapper cm) {
- boolean first = true;
-
- StringBuilder buf = new StringBuilder();
-
- for (Vector.Element x : vec.all()) {
- double d = x.get();
-
- String s = dataColorJson(d, cm.apply(d));
-
- if (!first)
- buf.append(", ");
-
- buf.append(s);
-
- first = false;
- }
-
- return '[' + buf.toString() + ']';
- }
-
- /**
- * Gets JavaScript array presentation of this vector.
- *
- * @param mtx Matrix to JavaScript-ify.
- * @param cm Color mapper to user.
- */
- private static String mkJsArrayString(Matrix mtx, ColorMapper cm) {
- boolean first = true;
-
- StringBuilder buf = new StringBuilder();
-
- int rows = mtx.rowSize();
- int cols = mtx.columnSize();
-
- for (int row = 0; row < rows; row++) {
- StringBuilder rowBuf = new StringBuilder();
-
- boolean rowFirst = true;
-
- for (int col = 0; col < cols; col++) {
- double d = mtx.get(row, col);
-
- String s = dataColorJson(d, cm.apply(d));
-
- if (!rowFirst)
- rowBuf.append(", ");
-
- rowBuf.append(s);
-
- rowFirst = false;
- }
-
- if (!first)
- buf.append(", ");
-
- buf.append('[').append(rowBuf.toString()).append(']');
-
- first = false;
- }
-
- return '[' + buf.toString() + ']';
- }
-
- /**
- * @param mtx Matrix to log.
- * @param fmt Output format.
- * @return Formatted representation of a matrix.
- */
- private static String mkString(Matrix mtx, String fmt) {
- StringBuilder buf = new StringBuilder();
-
- int rows = mtx.rowSize();
- int cols = mtx.columnSize();
-
- for (int row = 0; row < rows; row++) {
- for (int col = 0; col < cols; col++) {
- String s = String.format(Locale.US, fmt, mtx.get(row, col));
-
- if (col != 0)
- buf.append(", ");
-
- buf.append(s);
-
- if (col == cols - 1 && row != rows - 1)
- buf.append(",\n");
-
- }
- }
-
- return buf.toString();
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/ValueMapper.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/ValueMapper.java b/modules/math/src/main/java/org/apache/ignite/math/ValueMapper.java
deleted file mode 100644
index 9459bd1..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/ValueMapper.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// @java.file.header
-
-/* _________ _____ __________________ _____
- * __ ____/___________(_)______ /__ ____/______ ____(_)_______
- * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
- * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
- * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
- */
-
-package org.apache.ignite.math;
-
-import java.io.Serializable;
-
-/**
- * Utility mapper that can be used to map arbitrary values types to and from double.
- */
-public interface ValueMapper<V> extends Serializable {
- /**
- * @param v
- */
- public V fromDouble(double v);
-
- /**
- * @param v
- */
- public double toDouble(V v);
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/Vector.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/Vector.java b/modules/math/src/main/java/org/apache/ignite/math/Vector.java
deleted file mode 100644
index ac2a6c7..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/Vector.java
+++ /dev/null
@@ -1,498 +0,0 @@
-/*
- * 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;
-
-import java.io.Externalizable;
-import java.util.Spliterator;
-import java.util.function.IntToDoubleFunction;
-import org.apache.ignite.lang.IgniteUuid;
-import org.apache.ignite.math.exceptions.CardinalityException;
-import org.apache.ignite.math.exceptions.IndexException;
-import org.apache.ignite.math.exceptions.UnsupportedOperationException;
-import org.apache.ignite.math.functions.IgniteBiFunction;
-import org.apache.ignite.math.functions.IgniteDoubleFunction;
-
-/**
- * A vector interface.
- *
- * Based on its flavor it can have vastly different implementations tailored for
- * for different types of data (e.g. dense vs. sparse), different sizes of data or different operation
- * optimizations.
- *
- * Note also that not all operations can be supported by all underlying implementations. If an operation is not
- * supported a {@link UnsupportedOperationException} is thrown. This exception can also be thrown in partial cases
- * where an operation is unsupported only in special cases, e.g. where a given operation cannot be deterministically
- * completed in polynomial time.
- *
- * Based on ideas from <a href="http://mahout.apache.org/">Apache Mahout</a>.
- */
-public interface Vector extends MetaAttributes, Externalizable, StorageOpsMetrics, Destroyable {
- /**
- * Holder for vector's element.
- */
- interface Element {
- /**
- * Gets element's value.
- *
- * @return The value of this vector element.
- */
- double get();
-
- /**
- * Gets element's index in the vector.
- *
- * @return The index of this vector element.
- */
- int index();
-
- /**
- * Sets element's value.
- *
- * @param val Value to set.
- */
- void set(double val);
- }
-
- /**
- * Gets cardinality of this vector (maximum number of the elements).
- *
- * @return This vector's cardinality.
- */
- public int size();
-
- /**
- * Creates new copy of this vector.
- *
- * @return New copy vector.
- */
- public Vector copy();
-
- /**
- * Gets iterator over all elements in this vector.
- *
- * NOTE: implementation can choose to reuse {@link Element} instance so you need to copy it
- * if you want to retain it outside of iteration.
- *
- * @return Iterator.
- */
- public Iterable<Element> all();
-
- /**
- * Iterates ove all non-zero elements in this vector.
- *
- * NOTE: implementation can choose to reuse {@link Element} instance so you need to copy it
- * if you want to retain it outside of iteration.
- *
- * @return Iterator.
- */
- public Iterable<Element> nonZeroes();
-
- /**
- * Gets spliterator for all values in this vector.
- *
- * @return Spliterator for all values.
- */
- public Spliterator<Double> allSpliterator();
-
- /**
- * Gets spliterator for all non-zero values in this vector.
- *
- * @return Spliterator for all non-zero values.
- */
- public Spliterator<Double> nonZeroSpliterator();
-
- /**
- * Sorts this vector in ascending order.
- */
- public Vector sort();
-
- /**
- * Gets element at the given index.
- *
- * NOTE: implementation can choose to reuse {@link Element} instance so you need to copy it
- * if you want to retain it outside of iteration.
- *
- * @param idx Element's index.
- * @return Vector's element at the given index.
- * @throws IndexException Throw if index is out of bounds.
- */
- public Element getElement(int idx);
-
- /**
- * Assigns given value to all elements of this vector.
- *
- * @param val Value to assign.
- * @return This vector.
- */
- public Vector assign(double val);
-
- /**
- * Assigns values from given array to this vector.
- *
- * @param vals Values to assign.
- * @return This vector.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector assign(double[] vals);
-
- /**
- * Copies values from the argument vector to this one.
- *
- * @param vec Argument vector.
- * @return This vector.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector assign(Vector vec);
-
- /**
- * Assigns each vector element to the value generated by given function.
- *
- * @param fun Function that takes the index and returns value.
- * @return This vector.
- */
- public Vector assign(IntToDoubleFunction fun);
-
- /**
- * Maps all values in this vector through a given function.
- *
- * @param fun Mapping function.
- * @return This vector.
- */
- public Vector map(IgniteDoubleFunction<Double> fun);
-
- /**
- * Maps all values in this vector through a given function.
- *
- * For this vector <code>A</code>, argument vector <code>B</code> and the
- * function <code>F</code> this method maps every element <code>x</code> as:
- * <code>A(x) = F(A(x), B(x))</code>
- *
- * @param vec Argument vector.
- * @param fun Mapping function.
- * @return This function.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector map(Vector vec, IgniteBiFunction<Double, Double, Double> fun);
-
- /**
- * Maps all elements of this vector by applying given function to each element with a constant
- * second parameter <code>y</code>.
- *
- * @param fun Mapping function.
- * @param y Second parameter for mapping function.
- * @return This vector.
- */
- public Vector map(IgniteBiFunction<Double, Double, Double> fun, double y);
-
- /**
- * Creates new vector containing values from this vector divided by the argument.
- *
- * @param x Division argument.
- * @return New vector.
- */
- public Vector divide(double x);
-
- /**
- * Gets dot product of two vectors.
- *
- * @param vec Argument vector.
- * @return Dot product of two vectors.
- */
- public double dot(Vector vec);
-
- /**
- * Gets the value at specified index.
- *
- * @param idx Vector index.
- * @return Vector value.
- * @throws IndexException Throw if index is out of bounds.
- */
- public double get(int idx);
-
- /**
- * Gets the value at specified index without checking for index boundaries.
- *
- * @param idx Vector index.
- * @return Vector value.
- */
- public double getX(int idx);
-
- /**
- * Creates new empty vector of the same underlying class but of different cardinality.
- *
- * @param crd Cardinality for new vector.
- * @return New vector.
- */
- public Vector like(int crd);
-
- /**
- * Creates new matrix of compatible flavor with given size.
- *
- * @param rows Number of rows.
- * @param cols Number of columns.
- * @return New matrix.
- */
- public Matrix likeMatrix(int rows, int cols);
-
- /**
- * Converts this vector into [N x 1] or [1 x N] matrix where N is this vector cardinality.
- *
- * @param rowLike {@code true} for rowLike [N x 1], or {@code false} for column [1 x N] matrix.
- * @return Newly created matrix.
- */
- public Matrix toMatrix(boolean rowLike);
-
- /**
- * Converts this vector into [N+1 x 1] or [1 x N+1] matrix where N is this vector cardinality.
- * (0,0) element of this matrix will be {@code zeroVal} parameter.
- *
- * @param rowLike {@code true} for rowLike [N+1 x 1], or {@code false} for column [1 x N+1] matrix.
- * @return Newly created matrix.
- */
- public Matrix toMatrixPlusOne(boolean rowLike, double zeroVal);
-
- /**
- * Creates new vector containing element by element difference between this vector and the argument one.
- *
- * @param vec Argument vector.
- * @return New vector.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector minus(Vector vec);
-
- /**
- * Creates new vector containing the normalized (L_2 norm) values of this vector.
- *
- * @return New vector.
- */
- public Vector normalize();
-
- /**
- * Creates new vector containing the normalized (L_power norm) values of this vector.
- * See http://en.wikipedia.org/wiki/Lp_space for details.
- *
- * @param power The power to use. Must be >= 0. May also be {@link Double#POSITIVE_INFINITY}.
- * @return New vector {@code x} such that {@code norm(x, power) == 1}
- */
- public Vector normalize(double power);
-
- /**
- * Creates new vector containing the {@code log(1 + entry) / L_2 norm} values of this vector.
- *
- * @return New vector.
- */
- public Vector logNormalize();
-
- /**
- * Creates new vector with a normalized value calculated as {@code log_power(1 + entry) / L_power norm}.
- *
- * @param power The power to use. Must be > 1. Cannot be {@link Double#POSITIVE_INFINITY}.
- * @return New vector
- */
- public Vector logNormalize(double power);
-
- /**
- * Gets the k-norm of the vector. See http://en.wikipedia.org/wiki/Lp_space for more details.
- *
- * @param power The power to use.
- * @see #normalize(double)
- */
- public double kNorm(double power);
-
- /**
- * Gets minimal value in this vector.
- *
- * @return Minimal value.
- */
- public double minValue();
-
- /**
- * Gets maximum value in this vector.
- *
- * @return Maximum c.
- */
- public double maxValue();
-
- /**
- * Gets minimal element in this vector.
- *
- * @return Minimal element.
- */
- public Element minElement();
-
- /**
- * Gets maximum element in this vector.
- *
- * @return Maximum element.
- */
- public Element maxElement();
-
- /**
- * Creates new vector containing sum of each element in this vector and argument.
- *
- * @param x Argument value.
- * @return New vector.
- */
- public Vector plus(double x);
-
- /**
- * Creates new vector containing element by element sum from both vectors.
- *
- * @param vec Other argument vector to add.
- * @return New vector.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector plus(Vector vec);
-
- /**
- * Sets value.
- *
- * @param idx Vector index to set value at.
- * @param val Value to set.
- * @return This vector.
- * @throws IndexException Throw if index is out of bounds.
- */
- public Vector set(int idx, double val);
-
- /**
- * Sets value without checking for index boundaries.
- *
- * @param idx Vector index to set value at.
- * @param val Value to set.
- * @return This vector.
- */
- public Vector setX(int idx, double val);
-
- /**
- * Increments value at given index without checking for index boundaries.
- *
- * @param idx Vector index.
- * @param val Increment value.
- * @return This vector.
- */
- public Vector incrementX(int idx, double val);
-
- /**
- * Increments value at given index.
- *
- * @param idx Vector index.
- * @param val Increment value.
- * @return This vector.
- * @throws IndexException Throw if index is out of bounds.
- */
- public Vector increment(int idx, double val);
-
- /**
- * Gets number of non-zero elements in this vector.
- *
- * @return Number of non-zero elements in this vector.
- */
- public int nonZeroElements();
-
- /**
- * Gets a new vector that contains product of each element and the argument.
- *
- * @param x Multiply argument.
- * @return New vector.
- */
- public Vector times(double x);
-
- /**
- * Gets a new vector that is an element-wie product of this vector and the argument.
- *
- * @param vec Vector to multiply by.
- * @return New vector.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public Vector times(Vector vec);
-
- /**
- * @param off Offset into parent vector.
- * @param len Length of the view.
- */
- public Vector viewPart(int off, int len);
-
- /**
- * Gets vector storage model.
- */
- public VectorStorage getStorage();
-
- /**
- * Gets the sum of all elements in this vector.
- *
- * @return Vector's sum
- */
- public double sum();
-
- /**
- * Gets the cross product of this vector and the other vector.
- *
- * @param vec Second vector.
- * @return New matrix as a cross product of two vectors.
- */
- public Matrix cross(Vector vec);
-
- /**
- * Folds this vector into a single value.
- *
- * @param foldFun Folding function that takes two parameters: accumulator and the current value.
- * @param mapFun Mapping function that is called on each vector element before its passed to the accumulator (as its
- * second parameter).
- * @param <T> Type of the folded value.
- * @param zeroVal Zero value for fold operation.
- * @return Folded value of this vector.
- */
- public <T> T foldMap(IgniteBiFunction<T, Double, T> foldFun, IgniteDoubleFunction<Double> mapFun, T zeroVal);
-
- /**
- * Combines & maps two vector and folds them into a single value.
- *
- * @param vec Another vector to combine with.
- * @param foldFun Folding function.
- * @param combFun Combine function.
- * @param <T> Type of the folded value.
- * @param zeroVal Zero value for fold operation.
- * @return Folded value of these vectors.
- * @throws CardinalityException Thrown when cardinalities mismatch.
- */
- public <T> T foldMap(Vector vec, IgniteBiFunction<T, Double, T> foldFun, IgniteBiFunction<Double, Double, Double> combFun,
- T zeroVal);
-
- /**
- * Gets the sum of squares of all elements in this vector.
- *
- * @return Length squared value.
- */
- public double getLengthSquared();
-
- /**
- * Get the square of the distance between this vector and the argument vector.
- *
- * @param vec Another vector.
- * @return Distance squared.
- * @throws CardinalityException Thrown if cardinalities mismatch.
- */
- public double getDistanceSquared(Vector vec);
-
- /**
- * Auto-generated globally unique vector ID.
- *
- * @return Vector GUID.
- */
- public IgniteUuid guid();
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/VectorKeyMapper.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/VectorKeyMapper.java b/modules/math/src/main/java/org/apache/ignite/math/VectorKeyMapper.java
deleted file mode 100644
index 17d76f5..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/VectorKeyMapper.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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;
-
-/**
- * Maps {@link Vector} element index to cache key.
- */
-public interface VectorKeyMapper<K> extends KeyMapper<K> {
- /**
- * @param i Vector element index.
- * @return Cache key for given element index.
- */
- public K apply(int i);
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/VectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/VectorStorage.java b/modules/math/src/main/java/org/apache/ignite/math/VectorStorage.java
deleted file mode 100644
index f410254..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/VectorStorage.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * 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;
-
-import java.io.Externalizable;
-
-/**
- * Data storage support for {@link Vector}.
- */
-public interface VectorStorage extends Externalizable, StorageOpsMetrics, Destroyable {
- /**
- *
- *
- */
- public int size();
-
- /**
- * @param i Vector element index.
- * @return Value obtained for given element index.
- */
- public double get(int i);
-
- /**
- * @param i Vector element index.
- * @param v Value to set at given index.
- */
- public void set(int i, double v);
-
- /**
- * Gets underlying array if {@link StorageOpsMetrics#isArrayBased()} returns {@code true}.
- * Returns {@code null} if in other cases.
- *
- * @see StorageOpsMetrics#isArrayBased()
- */
- public default double[] data() {
- return null;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java
deleted file mode 100644
index 9554737..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/CholeskyDecomposition.java
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * 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.NonPositiveDefiniteMatrixException;
-import org.apache.ignite.math.exceptions.NonSymmetricMatrixException;
-
-/**
- * Calculates the Cholesky decomposition of a matrix.
- *
- * This class inspired by class from Apache Common Math with similar name.
- *
- * @see <a href="http://mathworld.wolfram.com/CholeskyDecomposition.html">MathWorld</a>
- * @see <a href="http://en.wikipedia.org/wiki/Cholesky_decomposition">Wikipedia</a>
- */
-public class CholeskyDecomposition extends DecompositionSupport {
- /**
- * Default threshold above which off-diagonal elements are considered too different
- * and matrix not symmetric.
- */
- public static final double DFLT_REL_SYMMETRY_THRESHOLD = 1.0e-15;
-
- /**
- * Default threshold below which diagonal elements are considered null
- * and matrix not positive definite.
- */
- public static final double DFLT_ABS_POSITIVITY_THRESHOLD = 1.0e-10;
-
- /** Row-oriented storage for L<sup>T</sup> matrix data. */
- private double[][] lTData;
- /** Cached value of L. */
- private Matrix cachedL;
- /** Cached value of LT. */
- private Matrix cachedLT;
- /** Origin matrix */
- private Matrix origin;
-
- /**
- * Calculates the Cholesky decomposition of the given matrix.
- *
- * Calling this constructor is equivalent to call {@link #CholeskyDecomposition(Matrix, double, double)} with the
- * thresholds set to the default values {@link #DFLT_REL_SYMMETRY_THRESHOLD} and
- * {@link #DFLT_ABS_POSITIVITY_THRESHOLD}.
- *
- * @param mtx the matrix to decompose.
- * @throws CardinalityException if matrix is not square.
- * @see #CholeskyDecomposition(Matrix, double, double)
- * @see #DFLT_REL_SYMMETRY_THRESHOLD
- * @see #DFLT_ABS_POSITIVITY_THRESHOLD
- */
- public CholeskyDecomposition(final Matrix mtx) {
- this(mtx, DFLT_REL_SYMMETRY_THRESHOLD, DFLT_ABS_POSITIVITY_THRESHOLD);
- }
-
- /**
- * Calculates the Cholesky decomposition of the given matrix.
- *
- * @param mtx the matrix to decompose.
- * @param relSymmetryThreshold threshold above which off-diagonal elements are considered too different and matrix
- * not symmetric
- * @param absPositivityThreshold threshold below which diagonal elements are considered null and matrix not positive
- * definite
- * @see #CholeskyDecomposition(Matrix)
- * @see #DFLT_REL_SYMMETRY_THRESHOLD
- * @see #DFLT_ABS_POSITIVITY_THRESHOLD
- */
- public CholeskyDecomposition(final Matrix mtx, final double relSymmetryThreshold,
- final double absPositivityThreshold) {
- assert mtx != null;
-
- if (mtx.columnSize() != mtx.rowSize())
- throw new CardinalityException(mtx.rowSize(), mtx.columnSize());
-
- origin = mtx;
-
- final int order = mtx.rowSize();
-
- lTData = toDoubleArr(mtx);
- cachedL = null;
- cachedLT = null;
-
- // Check the matrix before transformation.
- for (int i = 0; i < order; ++i) {
- final double[] lI = lTData[i];
-
- // Check off-diagonal elements (and reset them to 0).
- for (int j = i + 1; j < order; ++j) {
- final double[] lJ = lTData[j];
-
- final double lIJ = lI[j];
- final double lJI = lJ[i];
-
- final double maxDelta = relSymmetryThreshold * Math.max(Math.abs(lIJ), Math.abs(lJI));
-
- if (Math.abs(lIJ - lJI) > maxDelta)
- throw new NonSymmetricMatrixException(i, j, relSymmetryThreshold);
-
- lJ[i] = 0;
- }
- }
-
- // Transform the matrix.
- for (int i = 0; i < order; ++i) {
- final double[] ltI = lTData[i];
-
- // Check diagonal element.
- if (ltI[i] <= absPositivityThreshold)
- throw new NonPositiveDefiniteMatrixException(ltI[i], i, absPositivityThreshold);
-
- ltI[i] = Math.sqrt(ltI[i]);
- final double inverse = 1.0 / ltI[i];
-
- for (int q = order - 1; q > i; --q) {
- ltI[q] *= inverse;
- final double[] ltQ = lTData[q];
-
- for (int p = q; p < order; ++p)
- ltQ[p] -= ltI[q] * ltI[p];
- }
- }
- }
-
- /** */
- @Override public void destroy() {
- if (cachedL != null)
- cachedL.destroy();
- if (cachedLT != null)
- cachedLT.destroy();
- }
-
- /**
- * Returns the matrix L of the decomposition.
- * <p>L is an lower-triangular matrix</p>
- *
- * @return the L matrix
- */
- public Matrix getL() {
- if (cachedL == null)
- cachedL = getLT().transpose();
-
- return cachedL;
- }
-
- /**
- * Returns the transpose of the matrix L of the decomposition.
- * <p>L<sup>T</sup> is an upper-triangular matrix</p>
- *
- * @return the transpose of the matrix L of the decomposition
- */
- public Matrix getLT() {
-
- if (cachedLT == null) {
- Matrix like = like(origin, origin.rowSize(), origin.columnSize());
- like.assign(lTData);
-
- cachedLT = like;
- }
-
- // return the cached matrix
- return cachedLT;
- }
-
- /**
- * Return the determinant of the matrix
- *
- * @return determinant of the matrix
- */
- public double getDeterminant() {
- double determinant = 1.0;
-
- for (int i = 0; i < lTData.length; ++i) {
- double lTii = lTData[i][i];
- determinant *= lTii * lTii;
- }
-
- return determinant;
- }
-
- /**
- * Solve the linear equation A × X = B for matrices A.
- *
- * @param b right-hand side of the equation A × X = B
- * @return a vector X that minimizes the two norm of A × X - B
- * @throws CardinalityException if the vectors dimensions do not match
- */
- public Vector solve(final Vector b) {
- final int m = lTData.length;
-
- if (b.size() != m)
- throw new CardinalityException(b.size(), m);
-
- final double[] x = b.getStorage().data();
-
- // Solve LY = b
- for (int j = 0; j < m; j++) {
- final double[] lJ = lTData[j];
-
- x[j] /= lJ[j];
-
- final double xJ = x[j];
-
- for (int i = j + 1; i < m; i++)
- x[i] -= xJ * lJ[i];
- }
-
- // Solve LTX = Y
- for (int j = m - 1; j >= 0; j--) {
- x[j] /= lTData[j][j];
-
- final double xJ = x[j];
-
- for (int i = 0; i < j; i++)
- x[i] -= xJ * lTData[i][j];
- }
-
- return likeVector(origin, m).assign(x);
- }
-
- /**
- * Solve the linear equation A × X = B for matrices A.
- *
- * @param b right-hand side of the equation A × X = B
- * @return a matrix X that minimizes the two norm of A × X - B
- * @throws CardinalityException if the matrices dimensions do not match
- */
- public Matrix solve(final Matrix b) {
- final int m = lTData.length;
-
- if (b.rowSize() != m)
- throw new CardinalityException(b.rowSize(), m);
-
- final int nColB = b.columnSize();
- final double[][] x = b.getStorage().data();
-
- // Solve LY = b
- for (int j = 0; j < m; j++) {
- final double[] lJ = lTData[j];
- final double lJJ = lJ[j];
- final double[] xJ = x[j];
-
- for (int k = 0; k < nColB; ++k)
- xJ[k] /= lJJ;
-
- for (int i = j + 1; i < m; i++) {
- final double[] xI = x[i];
- final double lJI = lJ[i];
-
- for (int k = 0; k < nColB; ++k)
- xI[k] -= xJ[k] * lJI;
- }
- }
-
- // Solve LTX = Y
- for (int j = m - 1; j >= 0; j--) {
- final double lJJ = lTData[j][j];
- final double[] xJ = x[j];
-
- for (int k = 0; k < nColB; ++k)
- xJ[k] /= lJJ;
-
- for (int i = 0; i < j; i++) {
- final double[] xI = x[i];
- final double lIJ = lTData[i][j];
-
- for (int k = 0; k < nColB; ++k)
- xI[k] -= xJ[k] * lIJ;
- }
- }
-
- return like(origin, m, b.columnSize()).assign(x);
- }
-
- /** */
- private double[][] toDoubleArr(Matrix mtx) {
- if (mtx.isArrayBased())
- return mtx.getStorage().data();
-
- double[][] res = new double[mtx.rowSize()][];
-
- for (int row = 0; row < mtx.rowSize(); row++) {
- res[row] = new double[mtx.columnSize()];
- for (int col = 0; col < mtx.columnSize(); col++)
- res[row][col] = mtx.get(row, col);
- }
-
- return res;
- }
-}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/math/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java
----------------------------------------------------------------------
diff --git a/modules/math/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java b/modules/math/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java
deleted file mode 100644
index 2c76284..0000000
--- a/modules/math/src/main/java/org/apache/ignite/math/decompositions/DecompositionSupport.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * 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.Destroyable;
-import org.apache.ignite.math.Matrix;
-import org.apache.ignite.math.Vector;
-import org.apache.ignite.math.impls.matrix.CacheMatrix;
-import org.apache.ignite.math.impls.matrix.DenseLocalOnHeapMatrix;
-import org.apache.ignite.math.impls.matrix.PivotedMatrixView;
-import org.apache.ignite.math.impls.matrix.RandomMatrix;
-import org.apache.ignite.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;
- }
-}
[08/26] ignite git commit: IGNITE-5000 Rename Ignite Math module to
Ignite ML module
Posted by av...@apache.org.
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.java
new file mode 100644
index 0000000..099db38
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/DiagonalMatrixStorage.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.impls.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.Vector;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * {@link MatrixStorage} implementation for diagonal Matrix view.
+ */
+public class DiagonalMatrixStorage implements MatrixStorage {
+ /** Backing vector for matrix diagonal. */
+ private Vector diagonal;
+
+ /**
+ *
+ */
+ public DiagonalMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param diagonal Backing {@link Vector} for matrix diagonal.
+ */
+ public DiagonalMatrixStorage(Vector diagonal) {
+ assert diagonal != null;
+
+ this.diagonal = diagonal;
+ }
+
+ /**
+ *
+ */
+ public Vector diagonal() {
+ return diagonal;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return x == y ? diagonal.get(x) : 0.0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ if (x == y)
+ diagonal.set(x, v);
+ else
+ throw new UnsupportedOperationException("Can't set off-diagonal element.");
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return diagonal.size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return diagonal.size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(diagonal);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ diagonal = (Vector)in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return diagonal.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return diagonal.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return diagonal.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return diagonal.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + diagonal.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ DiagonalMatrixStorage that = (DiagonalMatrixStorage)o;
+
+ return diagonal.equals(that.diagonal);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java
new file mode 100644
index 0000000..6b0c6b4
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/FunctionMatrixStorage.java
@@ -0,0 +1,175 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IntIntDoubleToVoidFunction;
+import org.apache.ignite.math.functions.IntIntToDoubleFunction;
+
+/**
+ * Read-only or read-write function-based matrix storage.
+ */
+public class FunctionMatrixStorage implements MatrixStorage {
+ /** */ private int rows;
+ /** */ private int cols;
+
+ /** */ private IntIntToDoubleFunction getFunc;
+ /** */ private IntIntDoubleToVoidFunction setFunc;
+
+ /**
+ *
+ */
+ public FunctionMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param getFunc Function that returns value corresponding to given row and column index.
+ * @param setFunc Set function. If {@code null} - this will be a read-only matrix.
+ */
+ public FunctionMatrixStorage(int rows, int cols, IntIntToDoubleFunction getFunc,
+ IntIntDoubleToVoidFunction setFunc) {
+ assert rows > 0;
+ assert cols > 0;
+ assert getFunc != null;
+
+ this.rows = rows;
+ this.cols = cols;
+ this.getFunc = getFunc;
+ this.setFunc = setFunc;
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param getFunc Function that returns value corresponding to given row and column index.
+ */
+ public FunctionMatrixStorage(int rows, int cols, IntIntToDoubleFunction getFunc) {
+ this(rows, cols, getFunc, null);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return getFunc.apply(x, y);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ if (setFunc != null)
+ setFunc.apply(x, y, v);
+ else
+ throw new UnsupportedOperationException("Cannot set into read-only matrix.");
+ }
+
+ /**
+ *
+ */
+ public IntIntToDoubleFunction getFunction() {
+ return getFunc;
+ }
+
+ /**
+ *
+ */
+ public IntIntDoubleToVoidFunction setFunction() {
+ return setFunc;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(setFunc);
+ out.writeObject(getFunc);
+ out.writeInt(rows);
+ out.writeInt(cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ setFunc = (IntIntDoubleToVoidFunction)in.readObject();
+ getFunc = (IntIntToDoubleFunction)in.readObject();
+ rows = in.readInt();
+ cols = in.readInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ FunctionMatrixStorage that = (FunctionMatrixStorage)o;
+
+ return rows == that.rows && cols == that.cols
+ && (getFunc != null ? getFunc.equals(that.getFunc) : that.getFunc == null)
+ && (setFunc != null ? setFunc.equals(that.setFunc) : that.setFunc == null);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = rows;
+
+ res = 31 * res + cols;
+ res = 31 * res + (getFunc != null ? getFunc.hashCode() : 0);
+ res = 31 * res + (setFunc != null ? setFunc.hashCode() : 0);
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java
new file mode 100644
index 0000000..2e1fc12
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/MatrixDelegateStorage.java
@@ -0,0 +1,205 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.MatrixStorage;
+
+/**
+ * {@link MatrixStorage} implementation that delegates to parent matrix.
+ */
+public class MatrixDelegateStorage implements MatrixStorage {
+ /** Parent matrix storage. */
+ private MatrixStorage sto;
+
+ /** Row offset in the parent matrix. */
+ private int rowOff;
+ /** Column offset in the parent matrix. */
+ private int colOff;
+
+ /** Amount of rows in the matrix. */
+ private int rows;
+ /** Amount of columns in the matrix. */
+ private int cols;
+
+ /**
+ *
+ */
+ public MatrixDelegateStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param sto Backing parent storage.
+ * @param rowOff Row offset to parent matrix.
+ * @param colOff Column offset to parent matrix.
+ * @param rows Amount of rows in the view.
+ * @param cols Amount of columns in the view.
+ */
+ public MatrixDelegateStorage(MatrixStorage sto, int rowOff, int colOff, int rows, int cols) {
+ assert sto != null;
+ assert rowOff >= 0;
+ assert colOff >= 0;
+ assert rows > 0;
+ assert cols > 0;
+
+ this.sto = sto;
+
+ this.rowOff = rowOff;
+ this.colOff = colOff;
+
+ this.rows = rows;
+ this.cols = cols;
+ }
+
+ /**
+ *
+ */
+ public MatrixStorage delegate() {
+ return sto;
+ }
+
+ /**
+ *
+ */
+ public int rowOffset() {
+ return rowOff;
+ }
+
+ /**
+ *
+ */
+ public int columnOffset() {
+ return colOff;
+ }
+
+ /**
+ *
+ */
+ public int rowsLength() {
+ return rows;
+ }
+
+ /**
+ *
+ */
+ public int columnsLength() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return sto.get(rowOff + x, colOff + y);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ sto.set(rowOff + x, colOff + y, v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return sto.isArrayBased() && rowOff == 0 && colOff == 0;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return sto.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return sto.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return sto.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return sto.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[][] data() {
+ return sto.data();
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(sto);
+
+ out.writeInt(rowOff);
+ out.writeInt(colOff);
+
+ out.writeInt(rows);
+ out.writeInt(cols);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ sto = (MatrixStorage)in.readObject();
+
+ rowOff = in.readInt();
+ colOff = in.readInt();
+
+ rows = in.readInt();
+ cols = in.readInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + rows;
+ res = res * 37 + cols;
+ res = res * 37 + rowOff;
+ res = res * 37 + colOff;
+ res = res * 37 + sto.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ MatrixDelegateStorage that = (MatrixDelegateStorage)o;
+
+ return rows == that.rows && cols == that.cols && rowOff == that.rowOff && colOff == that.colOff &&
+ (sto != null ? sto.equals(that.sto) : that.sto == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java
new file mode 100644
index 0000000..32c8624
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/PivotedMatrixStorage.java
@@ -0,0 +1,256 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import org.apache.ignite.math.MatrixStorage;
+
+/**
+ * Pivoted (index mapped) view over another matrix storage implementation.
+ */
+public class PivotedMatrixStorage implements MatrixStorage {
+ /** Matrix storage. */
+ private MatrixStorage sto;
+
+ /** */
+ private int[] rowPivot;
+ /** */
+ private int[] colPivot;
+ /** */
+ private int[] rowUnpivot;
+ /** */
+ private int[] colUnpivot;
+
+ /**
+ *
+ */
+ public PivotedMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param sto Matrix storage.
+ * @param rowPivot Pivot array for rows.
+ * @param colPivot Pivot array for columns.
+ */
+ public PivotedMatrixStorage(MatrixStorage sto, int[] rowPivot, int[] colPivot) {
+ assert sto != null;
+ assert rowPivot != null;
+ assert colPivot != null;
+
+ this.sto = sto;
+ this.rowPivot = rowPivot;
+ this.colPivot = colPivot;
+
+ rowUnpivot = invert(rowPivot);
+ colUnpivot = invert(colPivot);
+ }
+
+ /**
+ *
+ */
+ public int[] rowPivot() {
+ return rowPivot;
+ }
+
+ /**
+ *
+ */
+ public int[] columnPivot() {
+ return colPivot;
+ }
+
+ /**
+ *
+ */
+ public int[] rowUnpivot() {
+ return rowUnpivot;
+ }
+
+ /**
+ *
+ */
+ public int[] columnUnpivot() {
+ return colUnpivot;
+ }
+
+ /**
+ * @param sto Matrix storage.
+ * @param pivot Pivot array.
+ */
+ public PivotedMatrixStorage(MatrixStorage sto, int[] pivot) {
+ this(sto, pivot, pivot == null ? null : java.util.Arrays.copyOf(pivot, pivot.length));
+ }
+
+ /**
+ * @param sto Matrix storage.
+ */
+ public PivotedMatrixStorage(MatrixStorage sto) {
+ this(sto, sto == null ? null : identityPivot(sto.rowSize()), sto == null ? null : identityPivot(sto.columnSize()));
+ }
+
+ /**
+ * @param i First row index to swap.
+ * @param j Second row index to swap.
+ */
+ public void swapRows(int i, int j) {
+ if (i != j) {
+ int tmp = rowPivot[i];
+
+ rowPivot[i] = rowPivot[j];
+ rowPivot[j] = tmp;
+
+ rowUnpivot[rowPivot[i]] = i;
+ rowUnpivot[rowPivot[j]] = j;
+ }
+ }
+
+ /**
+ * @param i First column index to swap.
+ * @param j Second column index to swap.
+ */
+ public void swapColumns(int i, int j) {
+ if (i != j) {
+ int tmp = colPivot[i];
+
+ colPivot[i] = colPivot[j];
+ colPivot[j] = tmp;
+
+ colUnpivot[colPivot[i]] = i;
+ colUnpivot[colPivot[j]] = j;
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ return sto.get(rowPivot[x], colPivot[y]);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ sto.set(rowPivot[x], colPivot[y], v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return sto.columnSize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return sto.rowSize();
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(sto);
+ out.writeObject(rowPivot);
+ out.writeObject(colPivot);
+ out.writeObject(rowUnpivot);
+ out.writeObject(colUnpivot);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ sto = (MatrixStorage)in.readObject();
+ rowPivot = (int[])in.readObject();
+ colPivot = (int[])in.readObject();
+ rowUnpivot = (int[])in.readObject();
+ colUnpivot = (int[])in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return sto.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return sto.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return sto.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return sto.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + sto.hashCode();
+ res = res * 37 + Arrays.hashCode(rowPivot);
+ res = res * 37 + Arrays.hashCode(rowUnpivot);
+ res = res * 37 + Arrays.hashCode(colPivot);
+ res = res * 37 + Arrays.hashCode(colUnpivot);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ PivotedMatrixStorage that = (PivotedMatrixStorage)obj;
+
+ return Arrays.equals(rowPivot, that.rowPivot) && Arrays.equals(rowUnpivot, that.rowUnpivot)
+ && Arrays.equals(colPivot, that.colPivot) && Arrays.equals(colUnpivot, that.colUnpivot)
+ && (sto != null ? sto.equals(that.sto) : that.sto == null);
+ }
+
+ /**
+ * @param n Pivot array length.
+ */
+ private static int[] identityPivot(int n) {
+ int[] pivot = new int[n];
+
+ for (int i = 0; i < n; i++)
+ pivot[i] = i;
+
+ return pivot;
+ }
+
+ /**
+ * @param pivot Pivot array to be inverted.
+ */
+ private static int[] invert(int[] pivot) {
+ int[] x = new int[pivot.length];
+
+ for (int i = 0; i < pivot.length; i++)
+ x[pivot[i]] = i;
+
+ return x;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java
new file mode 100644
index 0000000..8283201
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/RandomMatrixStorage.java
@@ -0,0 +1,176 @@
+/*
+ * 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.storage.matrix;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.nio.ByteBuffer;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.MurmurHash;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * {@link MatrixStorage} implementation with random values in the matrix elements.
+ */
+public class RandomMatrixStorage implements MatrixStorage {
+ /** */
+ private static final int PRIME1 = 104047;
+ /** */
+ private static final int PRIME2 = 101377;
+ /** */
+ private static final int PRIME3 = 64661;
+ /** */
+ private static final long SCALE = 1L << 32;
+
+ /** Random generation seed. */
+ private int seed;
+
+ /** Amount of rows in the matrix. */
+ private int rows;
+ /** Amount of columns in the matrix. */
+ private int cols;
+
+ /** Whether fast hash is used, in {@link #get(int, int)}. */
+ private boolean fastHash;
+
+ /**
+ * For externalization.
+ */
+ public RandomMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param fastHash Whether fast hash is used.
+ */
+ public RandomMatrixStorage(int rows, int cols, boolean fastHash) {
+ assert rows > 0;
+ assert cols > 0;
+
+ this.rows = rows;
+ this.cols = cols;
+ this.fastHash = fastHash;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ if (!fastHash) {
+ ByteBuffer buf = ByteBuffer.allocate(8);
+
+ buf.putInt(x);
+ buf.putInt(y);
+ buf.flip();
+
+ return (MurmurHash.hash64A(buf, seed) & (SCALE - 1)) / (double)SCALE;
+ }
+ else
+ // This isn't a fantastic random number generator, but it is just fine for random projections.
+ return ((((x * PRIME1) + y * PRIME2 + x * y * PRIME3) & 8) * 0.25) - 1;
+ }
+
+ /**
+ *
+ */
+ public boolean isFastHash() {
+ return fastHash;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ throw new UnsupportedOperationException("Random matrix storage is a read-only storage.");
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+ out.writeInt(seed);
+ out.writeBoolean(fastHash);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+ seed = in.readInt();
+ fastHash = in.readBoolean();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + Boolean.hashCode(fastHash);
+ res = res * 37 + seed;
+ res = res * 37 + cols;
+ res = res * 37 + rows;
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ RandomMatrixStorage that = (RandomMatrixStorage)o;
+
+ return rows == that.rows && cols == that.cols && seed == that.seed && fastHash == that.fastHash;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java
new file mode 100644
index 0000000..82807c5
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseDistributedMatrixStorage.java
@@ -0,0 +1,281 @@
+// @java.file.header
+
+/* _________ _____ __________________ _____
+ * __ ____/___________(_)______ /__ ____/______ ____(_)_______
+ * _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
+ * / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
+ * \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
+ */
+
+package org.apache.ignite.math.impls.storage.matrix;
+
+import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
+import it.unimi.dsi.fastutil.ints.Int2DoubleRBTreeMap;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Map;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.cache.CacheAtomicityMode;
+import org.apache.ignite.cache.CacheMode;
+import org.apache.ignite.cache.CachePeekMode;
+import org.apache.ignite.cache.CacheWriteSynchronizationMode;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.lang.IgniteUuid;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.StorageConstants;
+import org.apache.ignite.math.impls.CacheUtils;
+
+/**
+ * {@link MatrixStorage} implementation for {@link org.apache.ignite.math.impls.matrix.SparseDistributedMatrix}.
+ */
+public class SparseDistributedMatrixStorage extends CacheUtils implements MatrixStorage, StorageConstants {
+ /** Amount of rows in the matrix. */
+ private int rows;
+ /** Amount of columns in the matrix. */
+ private int cols;
+
+ /** Row or column based storage mode. */
+ private int stoMode;
+ /** Random or sequential access mode. */
+ private int acsMode;
+
+ /** Actual distributed storage. */
+ private IgniteCache<
+ Integer /* Row or column index. */,
+ Map<Integer, Double> /* Map-based row or column. */
+ > cache = null;
+
+ /**
+ *
+ */
+ public SparseDistributedMatrixStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param rows Amount of rows in the matrix.
+ * @param cols Amount of columns in the matrix.
+ * @param stoMode Row or column based storage mode.
+ * @param acsMode Random or sequential access mode.
+ */
+ public SparseDistributedMatrixStorage(int rows, int cols, int stoMode, int acsMode) {
+ assert rows > 0;
+ assert cols > 0;
+ assertAccessMode(acsMode);
+ assertStorageMode(stoMode);
+
+ this.rows = rows;
+ this.cols = cols;
+ this.stoMode = stoMode;
+ this.acsMode = acsMode;
+
+ cache = newCache();
+ }
+
+ /**
+ *
+ *
+ */
+ private IgniteCache<Integer, Map<Integer, Double>> newCache() {
+ CacheConfiguration<Integer, Map<Integer, Double>> cfg = new CacheConfiguration<>();
+
+ // Assume 10% density.
+ cfg.setStartSize(Math.max(1024, (rows * cols) / 10));
+
+ // Write to primary.
+ cfg.setWriteSynchronizationMode(CacheWriteSynchronizationMode.PRIMARY_SYNC);
+
+ // Atomic transactions only.
+ cfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
+
+ // No eviction.
+ cfg.setEvictionPolicy(null);
+
+ // No copying of values.
+ cfg.setCopyOnRead(false);
+
+ // Cache is partitioned.
+ cfg.setCacheMode(CacheMode.PARTITIONED);
+
+ // Random cache name.
+ cfg.setName(new IgniteUuid().shortString());
+
+ return Ignition.localIgnite().getOrCreateCache(cfg);
+ }
+
+ /**
+ *
+ *
+ */
+ public IgniteCache<Integer, Map<Integer, Double>> cache() {
+ return cache;
+ }
+
+ /**
+ *
+ *
+ */
+ public int accessMode() {
+ return acsMode;
+ }
+
+ /**
+ *
+ *
+ */
+ public int storageMode() {
+ return stoMode;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ if (stoMode == ROW_STORAGE_MODE)
+ return matrixGet(cache.getName(), x, y);
+ else
+ return matrixGet(cache.getName(), y, x);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ if (stoMode == ROW_STORAGE_MODE)
+ matrixSet(cache.getName(), x, y, v);
+ else
+ matrixSet(cache.getName(), y, x, v);
+ }
+
+ /**
+ * Distributed matrix get.
+ *
+ * @param cacheName Matrix's cache.
+ * @param a Row or column index.
+ * @param b Row or column index.
+ * @return Matrix value at (a, b) index.
+ */
+ private double matrixGet(String cacheName, int a, int b) {
+ // Remote get from the primary node (where given row or column is stored locally).
+ return ignite().compute(groupForKey(cacheName, a)).call(() -> {
+ IgniteCache<Integer, Map<Integer, Double>> cache = Ignition.localIgnite().getOrCreateCache(cacheName);
+
+ // Local get.
+ Map<Integer, Double> map = cache.localPeek(a, CachePeekMode.PRIMARY);
+
+ return (map == null || !map.containsKey(b)) ? 0.0 : map.get(b);
+ });
+ }
+
+ /**
+ * Distributed matrix set.
+ *
+ * @param cacheName Matrix's cache.
+ * @param a Row or column index.
+ * @param b Row or column index.
+ * @param v New value to set.
+ */
+ private void matrixSet(String cacheName, int a, int b, double v) {
+ // Remote set on the primary node (where given row or column is stored locally).
+ ignite().compute(groupForKey(cacheName, a)).run(() -> {
+ IgniteCache<Integer, Map<Integer, Double>> cache = Ignition.localIgnite().getOrCreateCache(cacheName);
+
+ // Local get.
+ Map<Integer, Double> map = cache.localPeek(a, CachePeekMode.PRIMARY);
+
+ if (map == null)
+ map = acsMode == SEQUENTIAL_ACCESS_MODE ? new Int2DoubleRBTreeMap() : new Int2DoubleOpenHashMap();
+
+ if (v != 0.0)
+ map.put(b, v);
+ else if (map.containsKey(b))
+ map.remove(b);
+
+ // Local put.
+ cache.put(a, map);
+ });
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+ out.writeInt(acsMode);
+ out.writeInt(stoMode);
+ out.writeUTF(cache.getName());
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+ acsMode = in.readInt();
+ stoMode = in.readInt();
+ cache = ignite().getOrCreateCache(in.readUTF());
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return acsMode == SEQUENTIAL_ACCESS_MODE;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return acsMode == RANDOM_ACCESS_MODE;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** Destroy underlying cache. */
+ @Override public void destroy() {
+ cache.destroy();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + cols;
+ res = res * 37 + rows;
+ res = res * 37 + acsMode;
+ res = res * 37 + stoMode;
+ res = res * 37 + cache.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ SparseDistributedMatrixStorage that = (SparseDistributedMatrixStorage)obj;
+
+ return rows == that.rows && cols == that.cols && acsMode == that.acsMode && stoMode == that.stoMode
+ && (cache != null ? cache.equals(that.cache) : that.cache == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java
new file mode 100644
index 0000000..e72da70
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/SparseLocalOnHeapMatrixStorage.java
@@ -0,0 +1,226 @@
+/*
+ * 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.storage.matrix;
+
+import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
+import it.unimi.dsi.fastutil.ints.Int2DoubleRBTreeMap;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.ignite.math.MatrixStorage;
+import org.apache.ignite.math.StorageConstants;
+
+/**
+ * Storage for sparse, local, on-heap matrix.
+ */
+public class SparseLocalOnHeapMatrixStorage implements MatrixStorage, StorageConstants {
+ /** Default zero value. */
+ private static final double DEFAULT_VALUE = 0.0;
+
+ /** */ private int rows;
+ /** */ private int cols;
+
+ /** */ private int acsMode;
+ /** */ private int stoMode;
+
+ /** Actual map storage. */
+ private Map<Integer, Map<Integer, Double>> sto;
+
+ /** */
+ public SparseLocalOnHeapMatrixStorage() {
+ // No-op.
+ }
+
+ /** */
+ public SparseLocalOnHeapMatrixStorage(int rows, int cols, int acsMode, int stoMode) {
+ assert rows > 0;
+ assert cols > 0;
+ assertAccessMode(acsMode);
+ assertStorageMode(stoMode);
+
+ this.rows = rows;
+ this.cols = cols;
+ this.acsMode = acsMode;
+ this.stoMode = stoMode;
+
+ sto = new HashMap<>();
+ }
+
+ /**
+ *
+ *
+ */
+ public int getStorageMode() {
+ return stoMode;
+ }
+
+ /**
+ *
+ *
+ */
+ public int getAccessMode() {
+ return acsMode;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int x, int y) {
+ if (stoMode == ROW_STORAGE_MODE) {
+ Map<Integer, Double> row = sto.get(x);
+
+ if (row != null) {
+ Double val = row.get(y);
+
+ if (val != null)
+ return val;
+ }
+
+ return DEFAULT_VALUE;
+ }
+ else {
+ Map<Integer, Double> col = sto.get(y);
+
+ if (col != null) {
+ Double val = col.get(x);
+
+ if (val != null)
+ return val;
+ }
+
+ return DEFAULT_VALUE;
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int x, int y, double v) {
+ // Ignore default values (currently 0.0).
+ if (v != DEFAULT_VALUE) {
+ if (stoMode == ROW_STORAGE_MODE) {
+ Map<Integer, Double> row = sto.computeIfAbsent(x, k ->
+ acsMode == SEQUENTIAL_ACCESS_MODE ? new Int2DoubleRBTreeMap() : new Int2DoubleOpenHashMap());
+
+ row.put(y, v);
+ }
+ else {
+ Map<Integer, Double> col = sto.computeIfAbsent(y, k ->
+ acsMode == SEQUENTIAL_ACCESS_MODE ? new Int2DoubleRBTreeMap() : new Int2DoubleOpenHashMap());
+
+ col.put(x, v);
+ }
+ }
+ else {
+ if (stoMode == ROW_STORAGE_MODE) {
+ if (sto.containsKey(x)) {
+ Map<Integer, Double> row = sto.get(x);
+
+ if (row.containsKey(y))
+ row.remove(y);
+ }
+
+ }
+ else {
+ if (sto.containsKey(y)) {
+ Map<Integer, Double> col = sto.get(y);
+
+ if (col.containsKey(x))
+ col.remove(x);
+ }
+ }
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override public int columnSize() {
+ return cols;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int rowSize() {
+ return rows;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(rows);
+ out.writeInt(cols);
+ out.writeInt(acsMode);
+ out.writeInt(stoMode);
+ out.writeObject(sto);
+ }
+
+ /** {@inheritDoc} */
+ @SuppressWarnings({"unchecked"})
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ rows = in.readInt();
+ cols = in.readInt();
+ acsMode = in.readInt();
+ stoMode = in.readInt();
+ sto = (Map<Integer, Map<Integer, Double>>)in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return acsMode == SEQUENTIAL_ACCESS_MODE;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return acsMode == RANDOM_ACCESS_MODE;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + rows;
+ res = res * 37 + cols;
+ res = res * 37 + sto.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ SparseLocalOnHeapMatrixStorage that = (SparseLocalOnHeapMatrixStorage)o;
+
+ return rows == that.rows && cols == that.cols && acsMode == that.acsMode && stoMode == that.stoMode
+ && (sto != null ? sto.equals(that.sto) : that.sto == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/package-info.java
new file mode 100644
index 0000000..aba47db
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/matrix/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 specific implementations for matrix storage models.
+ */
+package org.apache.ignite.math.impls.storage.matrix;
\ 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/storage/vector/ArrayVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java
new file mode 100644
index 0000000..ef59c62
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ArrayVectorStorage.java
@@ -0,0 +1,135 @@
+/*
+ * 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.storage.vector;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * Array based {@link VectorStorage} implementation.
+ */
+public class ArrayVectorStorage implements VectorStorage {
+ /** Backing data array. */
+ private double[] data;
+
+ /**
+ * IMPL NOTE required by {@link Externalizable}.
+ */
+ public ArrayVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size Vector size.
+ */
+ public ArrayVectorStorage(int size) {
+ assert size > 0;
+
+ data = new double[size];
+ }
+
+ /**
+ * @param data Backing data array.
+ */
+ public ArrayVectorStorage(double[] data) {
+ assert data != null;
+
+ this.data = data;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return data == null ? 0 : data.length;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return data[i];
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ data[i] = v;
+ }
+
+ /** {@inheritDoc}} */
+ @Override public boolean isArrayBased() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[] data() {
+ return data;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(data);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ data = (double[])in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + Arrays.hashCode(data);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ ArrayVectorStorage that = (ArrayVectorStorage)obj;
+
+ return Arrays.equals(data, (that.data));
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java
new file mode 100644
index 0000000..670deef
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/CacheVectorStorage.java
@@ -0,0 +1,175 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.math.ValueMapper;
+import org.apache.ignite.math.VectorKeyMapper;
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * Vector storage based on existing cache and index and value mapping functions.
+ */
+public class CacheVectorStorage<K, V> implements VectorStorage {
+ /** Storage size. */
+ private int size;
+ /** Key mapper. */
+ private VectorKeyMapper<K> keyMapper;
+ /** Value mapper. */
+ private ValueMapper<V> valMapper;
+ /** Underlying ignite cache. */
+ private IgniteCache<K, V> cache;
+
+ /**
+ *
+ */
+ public CacheVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size
+ * @param cache
+ * @param keyMapper
+ * @param valMapper
+ */
+ public CacheVectorStorage(int size, IgniteCache<K, V> cache, VectorKeyMapper<K> keyMapper,
+ ValueMapper<V> valMapper) {
+ assert size > 0;
+ assert cache != null;
+ assert keyMapper != null;
+ assert valMapper != null;
+
+ this.size = size;
+ this.cache = cache;
+ this.keyMapper = keyMapper;
+ this.valMapper = valMapper;
+ }
+
+ /**
+ *
+ *
+ */
+ public IgniteCache<K, V> cache() {
+ return cache;
+ }
+
+ /**
+ *
+ *
+ */
+ public VectorKeyMapper<K> keyMapper() {
+ return keyMapper;
+ }
+
+ /**
+ *
+ *
+ */
+ public ValueMapper<V> valueMapper() {
+ return valMapper;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return valMapper.toDouble(cache.get(keyMapper.apply(i)));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ cache.put(keyMapper.apply(i), valMapper.fromDouble(v));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(size);
+ out.writeObject(keyMapper);
+ out.writeObject(valMapper);
+ out.writeUTF(cache.getName());
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ size = in.readInt();
+ keyMapper = (VectorKeyMapper<K>)in.readObject();
+ valMapper = (ValueMapper<V>)in.readObject();
+ cache = Ignition.localIgnite().getOrCreateCache(in.readUTF());
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + size();
+ res = res * 37 + keyMapper.hashCode();
+ res = res * 37 + valMapper.hashCode();
+ res = res * 37 + cache.hashCode();
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+
+ CacheVectorStorage that = (CacheVectorStorage)obj;
+
+ return size == that.size
+ && (keyMapper != null ? keyMapper.getClass().equals(that.keyMapper.getClass()) : that.keyMapper == null)
+ && (valMapper != null ? valMapper.getClass().equals(that.valMapper.getClass()) : that.valMapper == null)
+ && (cache != null ? cache.equals(that.cache) : that.cache == null);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java
new file mode 100644
index 0000000..ff5ab26
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/ConstantVectorStorage.java
@@ -0,0 +1,133 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+
+/**
+ * Constant read-only vector storage.
+ */
+public class ConstantVectorStorage implements VectorStorage {
+ /** */ private int size;
+ /** */ private double val;
+
+ /**
+ *
+ */
+ public ConstantVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size Vector size.
+ * @param val Value to set for vector elements.
+ */
+ public ConstantVectorStorage(int size, double val) {
+ assert size > 0;
+
+ this.size = size;
+ this.val = val;
+ }
+
+ /**
+ *
+ *
+ */
+ public double constant() {
+ return val;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return val;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ throw new UnsupportedOperationException("Can't set value into constant vector.");
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(size);
+ out.writeDouble(val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ size = in.readInt();
+ val = in.readDouble();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + size;
+ res = res * 37 + Double.hashCode(val);
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ ConstantVectorStorage that = (ConstantVectorStorage)o;
+
+ return size == that.size && val == that.val;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java
new file mode 100644
index 0000000..aa6018c
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DelegateVectorStorage.java
@@ -0,0 +1,157 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * {@link VectorStorage} implementation that delegates to parent matrix.
+ */
+public class DelegateVectorStorage implements VectorStorage {
+ /** Parent vector storage. */
+ private VectorStorage sto;
+
+ /** Offset in the parent vector. */
+ private int off;
+
+ /** Size of the vector. */
+ private int len;
+
+ /**
+ *
+ */
+ public DelegateVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param sto Vector storage to delegate to.
+ * @param off Offset in the parent vector.
+ * @param len Size of the vector.
+ */
+ public DelegateVectorStorage(VectorStorage sto, int off, int len) {
+ assert sto != null;
+ assert off >= 0;
+ assert len > 0;
+
+ this.sto = sto;
+ this.off = off;
+ this.len = len;
+ }
+
+ /** */
+ public VectorStorage delegate() {
+ return sto;
+ }
+
+ /** */
+ public int offset() {
+ return off;
+ }
+
+ /** */
+ public int length() {
+ return len;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return len;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return sto.get(off + i);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ sto.set(off + i, v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[] data() {
+ return sto.data();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return sto.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return sto.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return sto.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return sto.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return sto.isArrayBased();
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(sto);
+ out.writeInt(off);
+ out.writeInt(len);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ sto = (VectorStorage)in.readObject();
+ off = in.readInt();
+ len = in.readInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ DelegateVectorStorage that = (DelegateVectorStorage)o;
+
+ return len == that.len && off == that.off && (sto != null ? sto.equals(that.sto) : that.sto == null);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + off;
+ res = res * 37 + len;
+ res = res * 37 + sto.hashCode();
+
+ return res;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java
new file mode 100644
index 0000000..2e7cdc9
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/DenseLocalOffHeapVectorStorage.java
@@ -0,0 +1,172 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.stream.IntStream;
+import org.apache.ignite.internal.util.GridUnsafe;
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * Local, dense off-heap vector storage.
+ */
+public class DenseLocalOffHeapVectorStorage implements VectorStorage {
+ /** Vector size. */
+ private int size;
+
+ /** */
+ private transient long ptr;
+ //TODO: temp solution.
+ /** */
+ private int ptrInitHash;
+
+ /**
+ *
+ */
+ public DenseLocalOffHeapVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param size Vector size.
+ */
+ public DenseLocalOffHeapVectorStorage(int size) {
+ assert size > 0;
+
+ this.size = size;
+
+ allocateMemory(size);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return GridUnsafe.getDouble(pointerOffset(i));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ GridUnsafe.putDouble(pointerOffset(i), v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[] data() {
+ return null;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeInt(size);
+ out.writeInt(ptrInitHash);
+
+ for (int i = 0; i < size; i++)
+ out.writeDouble(get(i));
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ size = in.readInt();
+
+ allocateMemory(size);
+
+ ptrInitHash = in.readInt();
+
+ for (int i = 0; i < size; i++)
+ set(i, in.readDouble());
+ }
+
+ /** {@inheritDoc} */
+ @Override public void destroy() {
+ GridUnsafe.freeMemory(ptr);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = 1;
+
+ res = res * 37 + size;
+ res = res * 37 + ptrInitHash;
+
+ return res;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ DenseLocalOffHeapVectorStorage that = (DenseLocalOffHeapVectorStorage)o;
+
+ return size == that.size && isMemoryEquals(that);
+ }
+
+ /** */
+ private boolean isMemoryEquals(DenseLocalOffHeapVectorStorage otherStorage) {
+ return IntStream.range(0, size).parallel().noneMatch(idx -> Double.compare(get(idx), otherStorage.get(idx)) != 0);
+ }
+
+ /**
+ * Pointer offset for specific index.
+ *
+ * @param i Offset index.
+ */
+ private long pointerOffset(int i) {
+ return ptr + i * Double.BYTES;
+ }
+
+ /** */
+ private void allocateMemory(int size) {
+ ptr = GridUnsafe.allocateMemory(size * Double.BYTES);
+
+ ptrInitHash = Long.hashCode(ptr);
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java
new file mode 100644
index 0000000..df8fa12
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/FunctionVectorStorage.java
@@ -0,0 +1,141 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.UnsupportedOperationException;
+import org.apache.ignite.math.functions.IgniteFunction;
+import org.apache.ignite.math.functions.IntDoubleToVoidFunction;
+
+/**
+ * Read-only or read-write function-based vector storage.
+ */
+public class FunctionVectorStorage implements VectorStorage {
+ /** */ private IgniteFunction<Integer, Double> getFunc;
+ /** */ private IntDoubleToVoidFunction setFunc;
+ /** */ private int size;
+
+ /**
+ *
+ */
+ public FunctionVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * Creates read-only or read-write storage.
+ *
+ * @param size Cardinality of this vector storage.
+ * @param getFunc Get function.
+ * @param setFunc Optional set function ({@code null} for read-only storage).
+ */
+ public FunctionVectorStorage(int size, IgniteFunction<Integer, Double> getFunc, IntDoubleToVoidFunction setFunc) {
+ assert size > 0;
+ assert getFunc != null; // At least get function is required.
+
+ this.size = size;
+ this.getFunc = getFunc;
+ this.setFunc = setFunc;
+ }
+
+ /**
+ *
+ *
+ */
+ public IgniteFunction<Integer, Double> getFunction() {
+ return getFunc;
+ }
+
+ /**
+ *
+ *
+ */
+ public IntDoubleToVoidFunction setFunction() {
+ return setFunc;
+ }
+
+ /**
+ * Creates read-only storage.
+ *
+ * @param size Cardinality of this vector storage.
+ * @param getFunc Get function.
+ */
+ public FunctionVectorStorage(int size, IgniteFunction<Integer, Double> getFunc) {
+ this(size, getFunc, null);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return getFunc.apply(i);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ if (setFunc != null)
+ setFunc.accept(i, v);
+ else
+ throw new UnsupportedOperationException("Cannot set into read-only vector.");
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(setFunc);
+ out.writeObject(getFunc);
+ out.writeInt(size);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ setFunc = (IntDoubleToVoidFunction)in.readObject();
+ getFunc = (IgniteFunction<Integer, Double>)in.readObject();
+ size = in.readInt();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java
new file mode 100644
index 0000000..ece0003
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/MatrixVectorStorage.java
@@ -0,0 +1,185 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import org.apache.ignite.math.Matrix;
+import org.apache.ignite.math.VectorStorage;
+import org.apache.ignite.math.exceptions.IndexException;
+
+/**
+ * Row, column or diagonal vector-based view of the matrix
+ */
+public class MatrixVectorStorage implements VectorStorage {
+ /** */ private Matrix parent;
+
+ /** */ private int row;
+ /** */ private int col;
+
+ /** */ private int rowStride;
+ /** */ private int colStride;
+
+ /** */ private int size;
+
+ /**
+ *
+ */
+ public MatrixVectorStorage() {
+ // No-op.
+ }
+
+ /**
+ * @param parent
+ * @param row
+ * @param col
+ * @param rowStride
+ * @param colStride
+ */
+ public MatrixVectorStorage(Matrix parent, int row, int col, int rowStride, int colStride) {
+ assert parent != null;
+ assert rowStride >= 0;
+ assert colStride >= 0;
+ assert rowStride > 0 || colStride > 0;
+
+ if (row < 0 || row >= parent.rowSize())
+ throw new IndexException(row);
+ if (col < 0 || col >= parent.columnSize())
+ throw new IndexException(col);
+
+ this.parent = parent;
+
+ this.row = row;
+ this.col = col;
+
+ this.rowStride = rowStride;
+ this.colStride = colStride;
+
+ this.size = getSize();
+ }
+
+ /**
+ *
+ *
+ */
+ int row() {
+ return row;
+ }
+
+ /**
+ *
+ *
+ */
+ int column() {
+ return col;
+ }
+
+ /**
+ *
+ *
+ */
+ int rowStride() {
+ return rowStride;
+ }
+
+ /**
+ *
+ *
+ */
+ int columnStride() {
+ return colStride;
+ }
+
+ /**
+ *
+ *
+ */
+ private int getSize() {
+ if (rowStride != 0 && colStride != 0) {
+ int n1 = (parent.rowSize() - row) / rowStride;
+ int n2 = (parent.columnSize() - col) / colStride;
+
+ return Math.min(n1, n2);
+ }
+ else if (rowStride > 0)
+ return (parent.rowSize() - row) / rowStride;
+ else
+ return (parent.columnSize() - col) / colStride;
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return size;
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return parent.get(row + i * rowStride, col + i * colStride);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ parent.set(row + i * rowStride, col + i * colStride, v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return parent.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return parent.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return parent.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return parent.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(parent);
+ out.writeInt(row);
+ out.writeInt(col);
+ out.writeInt(rowStride);
+ out.writeInt(colStride);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ parent = (Matrix)in.readObject();
+ row = in.readInt();
+ col = in.readInt();
+ rowStride = in.readInt();
+ colStride = in.readInt();
+
+ size = getSize();
+ }
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/732dfea9/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java
----------------------------------------------------------------------
diff --git a/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java
new file mode 100644
index 0000000..f69e959
--- /dev/null
+++ b/modules/ml/src/main/java/org/apache/ignite/math/impls/storage/vector/PivotedVectorStorage.java
@@ -0,0 +1,175 @@
+/*
+ * 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.storage.vector;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Arrays;
+import org.apache.ignite.math.VectorStorage;
+
+/**
+ * Pivoted (index mapped) view over another vector storage implementation.
+ */
+public class PivotedVectorStorage implements VectorStorage {
+ /** */ private VectorStorage sto;
+
+ /** */ private int[] pivot;
+ /** */ private int[] unpivot;
+
+ /**
+ * @param pivot Pivot array.
+ */
+ private static int[] reverse(int[] pivot) {
+ int[] res = new int[pivot.length];
+
+ for (int i = 0; i < pivot.length; i++)
+ res[pivot[i]] = i;
+
+ return res;
+ }
+
+ /**
+ *
+ *
+ */
+ public int[] pivot() {
+ return pivot;
+ }
+
+ /**
+ *
+ *
+ */
+ public int[] unpivot() {
+ return unpivot;
+ }
+
+ /**
+ * @param sto Backing vector storage.
+ * @param pivot Mapping from external index to internal.
+ * @param unpivot Mapping from internal index to external.
+ */
+ public PivotedVectorStorage(VectorStorage sto, int[] pivot, int[] unpivot) {
+ assert sto != null;
+ assert pivot != null;
+ assert unpivot != null;
+
+ this.sto = sto;
+ this.pivot = pivot;
+ this.unpivot = unpivot;
+ }
+
+ /**
+ * @param sto Backing vector storage.
+ * @param pivot Mapping from external index to internal.
+ */
+ public PivotedVectorStorage(VectorStorage sto, int[] pivot) {
+ this(sto, pivot, reverse(pivot));
+ }
+
+ /**
+ *
+ */
+ public PivotedVectorStorage() {
+ // No-op.
+ }
+
+ /** {@inheritDoc} */
+ @Override public int size() {
+ return sto.size();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double get(int i) {
+ return sto.get(pivot[i]);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void set(int i, double v) {
+ sto.set(pivot[i], v);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(sto);
+ out.writeObject(pivot);
+ out.writeObject(unpivot);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ sto = (VectorStorage)in.readObject();
+ pivot = (int[])in.readObject();
+ unpivot = (int[])in.readObject();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isSequentialAccess() {
+ return sto.isSequentialAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDense() {
+ return sto.isDense();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isRandomAccess() {
+ return sto.isRandomAccess();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isDistributed() {
+ return sto.isDistributed();
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean isArrayBased() {
+ return sto.isArrayBased();
+ }
+
+ /** {@inheritDoc} */
+ @Override public double[] data() {
+ return isArrayBased() ? sto.data() : null;
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean equals(Object o) {
+ if (this == o)
+ return true;
+
+ if (o == null || getClass() != o.getClass())
+ return false;
+
+ PivotedVectorStorage that = (PivotedVectorStorage)o;
+
+ return (sto != null ? sto.equals(that.sto) : that.sto == null) && Arrays.equals(pivot, that.pivot)
+ && Arrays.equals(unpivot, that.unpivot);
+ }
+
+ /** {@inheritDoc} */
+ @Override public int hashCode() {
+ int res = sto != null ? sto.hashCode() : 0;
+
+ res = 31 * res + Arrays.hashCode(pivot);
+ res = 31 * res + Arrays.hashCode(unpivot);
+
+ return res;
+ }
+}