private static void testSkipsLast(Vector vector) { vector.set(1, 6); vector.set(98, 6); // Test non zero iterator. Iterator<Element> it = vector.nonZeroes().iterator(); int i = 0; while (it.hasNext()) { // hasNext is called more often than next it.next(); ++i; } assertEquals(2, i); // Last element is print only once. // Test all iterator. it = vector.all().iterator(); i = 0; while (it.hasNext()) { // hasNext is called more often than next Element element = it.next(); assertEquals(i, element.index()); ++i; } assertFalse(it.hasNext()); assertEquals(99, i); // Last element is print only once. }
@Test public void testEmptyAggregate1() { assertEquals(1.0, new DenseVector(new double[]{1}).aggregate(Functions.MIN, Functions.IDENTITY), EPSILON); assertEquals(1.0, new DenseVector(new double[]{2, 1}).aggregate(Functions.MIN, Functions.IDENTITY), EPSILON); assertEquals(0, new DenseVector(new double[0]).aggregate(Functions.MIN, Functions.IDENTITY), 0); }
private static void doTestIterators(Vector vector, Collection<Integer> expectedIndices) { expectedIndices = Sets.newHashSet(expectedIndices); Iterator<Element> allIterator = vector.all().iterator(); int index = 0; while (allIterator.hasNext()) { Element element = allIterator.next(); assertEquals(index, element.index()); if (expectedIndices.contains(index)) { assertEquals((double) index * 2, element.get(), EPSILON); } else { assertEquals(0.0, element.get(), EPSILON); } index++; } for (Element element : vector.nonZeroes()) { index = element.index(); assertTrue(expectedIndices.contains(index)); assertEquals((double) index * 2, element.get(), EPSILON); expectedIndices.remove(index); } assertTrue(expectedIndices.isEmpty()); }
private static void testEmptyNonZeroIterator(Vector vector) { // Test non zero iterator. Iterator<Element> it = vector.nonZeroes().iterator(); int i = 0; while (it.hasNext()) { ++i; } assertEquals(0, i); it = vector.nonZeroes().iterator(); assertFalse(it.hasNext()); try { it.next(); fail(); } catch (NoSuchElementException e) { // expected; } }
private static void assertVectorEquals(Vector expected, Vector actual, double epsilon) { assertEquals(expected.size(), actual.size()); for (Element x : expected.all()) { assertEquals(x.get(), actual.get(x.index()), epsilon); } }
/** Asserts a vector using enumeration equals a given dense vector */ private static void doTestEnumeration(double[] apriori, Vector vector) { double[] test = new double[apriori.length]; for (Element e : vector.all()) { test[e.index()] = e.get(); } for (int i = 0; i < test.length; i++) { assertEquals(apriori[i], test[i], EPSILON); } }
private static void doTestGetDistanceSquared(Vector v, Vector w) { double expected = v.minus(w).getLengthSquared(); assertEquals(expected, v.getDistanceSquared(w), 1.0e-6); }
@Test public void testSparseVectorFullIteration() { int[] index = {0, 1, 2, 3, 4, 5}; double[] values = {1, 2, 3, 4, 5, 6}; assertEquals(index.length, values.length); int n = index.length; Vector vector = new SequentialAccessSparseVector(n); for (int i = 0; i < n; i++) { vector.set(index[i], values[i]); } for (int i = 0; i < n; i++) { assertEquals(vector.get(i), values[i], EPSILON); } int elements = 0; for (Element ignore : vector.all()) { elements++; } assertEquals(n, elements); assertFalse(new SequentialAccessSparseVector(0).iterator().hasNext()); }
@Test public void testSparseVectorSparseIteration() { int[] index = {0, 1, 2, 3, 4, 5}; double[] values = {1, 2, 3, 4, 5, 6}; assertEquals(index.length, values.length); int n = index.length; Vector vector = new SequentialAccessSparseVector(n); for (int i = 0; i < n; i++) { vector.set(index[i], values[i]); } for (int i = 0; i < n; i++) { assertEquals(vector.get(i), values[i], EPSILON); } int elements = 0; for (Element ignored : vector.nonZeroes()) { elements++; } assertEquals(n, elements); Vector empty = new SequentialAccessSparseVector(0); assertFalse(empty.nonZeroes().iterator().hasNext()); }
private static void testEmptyAllIterator(Vector vector) { // Test non zero iterator. Iterator<Element> it = vector.all().iterator(); int i = 0; while (it.hasNext()) { ++i; } assertEquals(0, i); it = vector.nonZeroes().iterator(); assertFalse(it.hasNext()); try { it.next(); fail(); } catch (NoSuchElementException e) { // expected; } it = vector.all().iterator(); assertFalse(it.hasNext()); try { it.next(); fail(); } catch (NoSuchElementException e) { // expected; } }
denseRight.setQuick(1, 2); denseRight.setQuick(2, 3); assertEquals(sparseLeft, denseRight); assertEquals(sparseLeft.hashCode(), denseRight.hashCode()); sparseLeft.setQuick(1, 2); sparseLeft.setQuick(2, 3); assertEquals(sparseLeft, denseRight); assertEquals(sparseLeft.hashCode(), denseRight.hashCode()); denseLeft.setQuick(1, 2); denseLeft.setQuick(2, 3); assertEquals(denseLeft, denseRight); assertEquals(denseLeft.hashCode(), denseRight.hashCode()); sparseRight.setQuick(1, 2); sparseRight.setQuick(2, 3); assertEquals(sparseLeft, sparseRight); assertEquals(sparseLeft.hashCode(), sparseRight.hashCode()); assertEquals(emptyLeft, emptyRight); assertEquals(emptyLeft.hashCode(), emptyRight.hashCode()); emptyRight = new RandomAccessSparseVector(0); assertEquals(emptyLeft, emptyRight); assertEquals(emptyLeft.hashCode(), emptyRight.hashCode());
++i; assertEquals(8, i); assertEquals(8, vector.getNumNonZeroElements()); assertEquals(8, i); assertEquals(7, vector.getNumNonZeroElements()); assertEquals(7, i); // This just got messed up. assertEquals(7, vector.getNumNonZeroElements());
@Test public void testEmptyAggregate2() { assertEquals(3.0, new DenseVector(new double[]{1}).aggregate( new DenseVector(new double[]{2}), Functions.MIN, Functions.PLUS), EPSILON); assertEquals(0, new DenseVector(new double[0]).aggregate(new DenseVector(new double[0]), Functions.MIN, Functions.PLUS), 0); }
assertEquals(element.get(), vector.get(element.index()), 0); ++i; assertEquals(7, i); // Last element is print only once. assertEquals(4, indexes.size()); assertTrue(indexes.contains(0)); assertTrue(indexes.contains(2)); assertEquals(element.index(), i/2); assertEquals(element.get(), vector.get(i/2), 0); ++i; assertEquals(197, i); // Last element is print only once.
private static void doTestAggregation(Vector v, Vector w) { assertEquals("aggregate(plus, pow(2)) not equal to " + v.getLengthSquared(), v.getLengthSquared(), v.aggregate(Functions.PLUS, Functions.pow(2)), EPSILON); assertEquals("aggregate(plus, abs) not equal to " + v.norm(1), v.norm(1), v.aggregate(Functions.PLUS, Functions.ABS), EPSILON); assertEquals("aggregate(max, abs) not equal to " + v.norm(Double.POSITIVE_INFINITY), v.norm(Double.POSITIVE_INFINITY), v.aggregate(Functions.MAX, Functions.ABS), EPSILON); assertEquals("v.dot(w) != v.aggregate(w, plus, mult)", v.dot(w), v.aggregate(w, Functions.PLUS, Functions.MULT), EPSILON); assertEquals("|(v-w)|^2 != v.aggregate(w, plus, chain(pow(2), minus))", v.minus(w).dot(v.minus(w)), v.aggregate(w, Functions.PLUS, Functions.chain(Functions.pow(2), Functions.MINUS)), EPSILON); }
@Test public void testNumNonZerosDense() { DenseVector vector = new DenseVector(10); vector.assign(1); vector.setQuick(3, 0); vector.set(5, 0); assertEquals(8, vector.getNumNonZeroElements()); }
private static void doTestVectors(Vector left, Vector right) { left.setQuick(0, 1); left.setQuick(1, 2); left.setQuick(2, 3); right.setQuick(0, 4); right.setQuick(1, 5); right.setQuick(2, 6); double result = left.dot(right); assertEquals(32.0, result, EPSILON); }
@Test public void testNumNonZerosRandomAccessSparse() { RandomAccessSparseVector vector = new RandomAccessSparseVector(10); vector.setQuick(3, 1); vector.set(5, 1); vector.setQuick(7, 0); vector.set(9, 0); assertEquals(2, vector.getNumNonZeroElements()); }
@Test public void testNumNonZerosSequentialAccessSparse() { SequentialAccessSparseVector vector = new SequentialAccessSparseVector(10); vector.setQuick(3, 1); vector.set(5, 1); vector.setQuick(7, 0); vector.set(9, 0); assertEquals(2, vector.getNumNonZeroElements()); }
@Test public void testAddTo() throws Exception { Vector v = new DenseVector(4); Vector w = new DenseVector(4); v.setQuick(0, 1); v.setQuick(1, 2); v.setQuick(2, 0); v.setQuick(3, 4); w.setQuick(0, 1); w.setQuick(1, 1); w.setQuick(2, 1); w.setQuick(3, 1); w.assign(v, Functions.PLUS); Vector gold = new DenseVector(new double[]{2, 3, 1, 5}); assertEquals(w, gold); assertFalse(v.equals(gold)); }