Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 59990200C7E for ; Tue, 18 Apr 2017 07:39:15 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 5837D160BAE; Tue, 18 Apr 2017 05:39:15 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id F26E5160BBC for ; Tue, 18 Apr 2017 07:39:12 +0200 (CEST) Received: (qmail 56946 invoked by uid 500); 18 Apr 2017 05:39:12 -0000 Mailing-List: contact commits-help@ignite.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@ignite.apache.org Delivered-To: mailing list commits@ignite.apache.org Received: (qmail 54958 invoked by uid 99); 18 Apr 2017 05:39:04 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 18 Apr 2017 05:39:04 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 284C7E178A; Tue, 18 Apr 2017 05:39:04 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: sboikov@apache.org To: commits@ignite.apache.org Date: Tue, 18 Apr 2017 05:39:25 -0000 Message-Id: <46309217298543589ddcd1ae2a407264@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [23/46] ignite git commit: IGNITE-5000 Rename Ignite Math module to Ignite ML module archived-at: Tue, 18 Apr 2017 05:39:15 -0000 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>> suppliers = Arrays.asList( - (Supplier>)DenseLocalOnHeapVectorFixture::new, - (Supplier>)DenseLocalOffHeapVectorFixture::new, - (Supplier>)SparseLocalVectorFixture::new, - (Supplier>)RandomVectorFixture::new, - (Supplier>)ConstantVectorFixture::new, - (Supplier>)DelegatingVectorFixture::new, - (Supplier>)FunctionVectorFixture::new, - (Supplier>)SingleElementVectorFixture::new, - (Supplier>)PivotedVectorViewFixture::new, - (Supplier>)SingleElementVectorViewFixture::new, - (Supplier>)MatrixVectorViewFixture::new, - (Supplier>)SparseLocalOffHeapVectorFixture::new - ); - - /** */ - void consumeSampleVectors(Consumer paramsConsumer, BiConsumer consumer) { - for (Supplier> fixtureSupplier : VectorImplementationsFixtures.suppliers) { - final Iterable 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 { - /** */ - 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 { - /** */ - 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 { - /** */ - 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 { - /** */ - 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 { - /** */ - private final Supplier> iter; - - /** */ - private final AtomicReference ctxDescrHolder = new AtomicReference<>("Iterator not started."); - - /** */ - SingleElementVectorFixture() { - iter = () -> new TwoParamsIterator("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 ctor() { - return (size, value) -> new SingleElementVector(size, 0, value); - } - }; - } - - /** {@inheritDoc} */ - @NotNull - @Override public Iterator 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 { - /** */ - private final Supplier> iter; - - /** */ - private final AtomicReference ctxDescrHolder = new AtomicReference<>("Iterator not started."); - - /** */ - SingleElementVectorViewFixture() { - iter = () -> new TwoParamsIterator("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 ctor() { - return (size, value) -> new SingleElementVectorView(new SingleElementVector(size, 0, value), 0); - } - }; - } - - /** {@inheritDoc} */ - @NotNull - @Override public Iterator 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 { - /** */ - 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 implements Iterable { - /** */ - private final Supplier> iter; - - /** */ - private final AtomicReference ctxDescrHolder = new AtomicReference<>("Iterator not started."); - - /** */ - VectorSizesExtraFixture(String vectorKind, BiFunction ctor, String extraParamName, - T[] extras) { - iter = () -> new VectorSizesExtraIterator<>(vectorKind, ctor, ctxDescrHolder::set, extraParamName, extras); - } - - /** {@inheritDoc} */ - @NotNull - @Override public Iterator 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 { - /** */ - private final Supplier iter; - - /** */ - private final AtomicReference ctxDescrHolder = new AtomicReference<>("Iterator not started."); - - /** */ - VectorSizesFixture(String vectorKind, Function ctor) { - iter = () -> new VectorSizesIterator(vectorKind, ctor, ctxDescrHolder::set); - } - - /** {@inheritDoc} */ - @NotNull - @Override public Iterator 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 extends VectorSizesIterator { - /** */ - private final T[] extras; - /** */ - private int extraIdx = 0; - /** */ - private final BiFunction 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 ctor, - Consumer 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 ctor() { - return (size, delta) -> ctor.apply(size + delta, extras[extraIdx]); - } - - /** */ - void selfTest() { - final Set 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 { - /** */ - private final Function ctor; - - /** */ - VectorSizesIterator(String vectorKind, Function ctor, Consumer 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 ctor() { - return (size, delta) -> ctor.apply(size + delta); - } - } - - /** */ - private static class TwoParamsIterator implements Iterator { - /** */ - private final T params1[]; - - /** */ - private final U params2[]; - - /** */ - private final String vectorKind; - - /** */ - private final String param1Name; - - /** */ - private final String param2Name; - - /** */ - private final BiFunction ctor; - - /** */ - private final Consumer ctxDescrConsumer; - - /** */ - private int param1Idx = 0; - - /** */ - private int param2Idx = 0; - - /** */ - TwoParamsIterator(String vectorKind, BiFunction ctor, - Consumer 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 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 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 { - - /** */ - private final Supplier> iter; - - /** */ - private final AtomicReference 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 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 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 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 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() { - /** {@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 expLikeType(Vector v) { - Class 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 calcRef, Function 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 operation, - BiFunction 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 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 operation, - BiFunction 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 consumer) { - consumeSampleVectors(null, consumer); - } - - /** */ - private void consumeSampleVectors(Consumer paramsConsumer, BiConsumer 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 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 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 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 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 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 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 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 calcRef, Function 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 operation, - Function 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 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> typesMap = typesMap(); - - /** */ - private static final List> likeMatrixUnsupported = Arrays.asList(FunctionVector.class, - SingleElementVector.class, SingleElementVectorView.class, ConstantVector.class); - - /** */ - @Test - public void testHaveLikeMatrix() throws InstantiationException, IllegalAccessException { - for (Class key : typesMap.keySet()) { - Class 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 key = v.getClass(); - - Class expMatrixType = typesMap.get(key); - - assertNotNull("Expect non-null matrix for " + key.getSimpleName() + " in " + desc, matrix); - - Class 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 clazz) { - for (Class ignoredClass : likeMatrixUnsupported) - if (ignoredClass.isAssignableFrom(clazz)) - return false; - - return true; - } - - /** */ - private void consumeSampleVectors(BiConsumer consumer) { - new VectorImplementationsFixtures().consumeSampleVectors(null, consumer); - } - - /** */ - private static Map, Class> typesMap() { - return new LinkedHashMap, Class>() {{ - 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 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 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 consumer) { - new VectorImplementationsFixtures().consumeSampleVectors(null, consumer); - } - -}