@Override public Vector like(int cardinality) { return new SequentialAccessSparseVector(cardinality); }
@Override Vector generateTestVector(int cardinality) { return new SequentialAccessSparseVector(cardinality); }
@SuppressWarnings("CloneDoesntCallSuperClone") @Override public SequentialAccessSparseVector clone() { return new SequentialAccessSparseVector(size(), values.clone()); }
@Override public SequentialAccessSparseVector like() { return new SequentialAccessSparseVector(size(), values.getNumMappings()); }
@Test public void testIteratorSasv() { testIterator(new SequentialAccessSparseVector(99)); testEmptyAllIterator(new SequentialAccessSparseVector(0)); testExample1NonZeroIterator(new SequentialAccessSparseVector(13)); }
@Override public SequentialAccessSparseVector vectorToTest(int size) { SequentialAccessSparseVector r = new SequentialAccessSparseVector(size); Random gen = RandomUtils.getRandom(); for (int i = 0; i < 3; i++) { r.set(gen.nextInt(r.size()), gen.nextGaussian()); } return r; }
@SuppressWarnings("unchecked") @Parameterized.Parameters public static Collection<Object[]> generateData() { List<Object[]> data = Lists.newArrayList(); for (List<?> entry : Sets.cartesianProduct(Lists.newArrayList( ImmutableSet.of(Functions.PLUS, Functions.PLUS_ABS, Functions.MAX), ImmutableSet.of(Functions.PLUS, Functions.PLUS_ABS, Functions.MULT, Functions.MULT_RIGHT_PLUS1, Functions.MINUS), ImmutableSet.copyOf(VectorBinaryAggregate.OPERATIONS), ImmutableSet.of(new SequentialAccessSparseVector(CARDINALITY), new RandomAccessSparseVector(CARDINALITY), new DenseVector(CARDINALITY)), ImmutableSet.of(new SequentialAccessSparseVector(CARDINALITY), new RandomAccessSparseVector(CARDINALITY), new DenseVector(CARDINALITY))))) { data.add(entry.toArray()); } return data; }
public SparseRowMatrix(int rows, int columns, Vector[] vectors, boolean shallowCopy, boolean randomAccess) { super(rows, columns); this.randomAccessRows = randomAccess; this.rowVectors = vectors.clone(); for (int row = 0; row < rows; row++) { if (vectors[row] == null) { // TODO: this can't be right to change the argument vectors[row] = randomAccess ? new RandomAccessSparseVector(numCols(), 10) : new SequentialAccessSparseVector(numCols(), 10); } this.rowVectors[row] = shallowCopy ? vectors[row] : vectors[row].clone(); } }
@Test public void testDotSuperBig() { Vector w = new SequentialAccessSparseVector(Integer.MAX_VALUE, 12); w.set(1, 0.4); w.set(2, 0.4); w.set(3, -0.666666667); Vector v = new SequentialAccessSparseVector(Integer.MAX_VALUE, 12); v.set(3, 1); assertEquals("super-big", -0.666666667, v.dot(w), EPSILON); }
@Test public void testAll() { SequentialAccessSparseVector x = new SequentialAccessSparseVector(CARDINALITY); for (int i = 0; i < x.size(); ++i) { x.setQuick(i, i); } SequentialAccessSparseVector y = new SequentialAccessSparseVector(x); System.out.printf("function %s; operation %s\n", function, operation); operation.assign(x, y, function); for (int i = 0; i < x.size(); ++i) { assertEquals(x.getQuick(i), function.apply(i, i), 0.0); } } }
@Test @Repeat(iterations = 20) public void testSequentialAccessSparseVectorWritable() throws Exception { Vector v = new SequentialAccessSparseVector(MAX_VECTOR_SIZE); createRandom(v); doTestVectorWritableEquals(v); }
@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()); }
@Test public void testVectorView() { RandomAccessSparseVector vec1 = new RandomAccessSparseVector(3); RandomAccessSparseVector vec2 = new RandomAccessSparseVector(6); SequentialAccessSparseVector vec3 = new SequentialAccessSparseVector(3); SequentialAccessSparseVector vec4 = new SequentialAccessSparseVector(6); Vector vecV1 = new VectorView(vec1, 0, 3); Vector vecV2 = new VectorView(vec2, 2, 3); Vector vecV3 = new VectorView(vec3, 0, 3); Vector vecV4 = new VectorView(vec4, 2, 3); doTestVectors(vecV1, vecV2); doTestVectors(vecV3, vecV4); }
@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 @Repeat(iterations = 20) public void testViewSequentialAccessSparseVectorWritable() throws Exception { Vector v = new SequentialAccessSparseVector(MAX_VECTOR_SIZE); createRandom(v); Vector view = new VectorView(v, 0, v.size()); doTestVectorWritableEquals(view); }
@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 testGetDistanceSquared() { Vector v = new DenseVector(5); Vector w = new DenseVector(5); setUpV(v); setUpW(w); doTestGetDistanceSquared(v, w); v = new RandomAccessSparseVector(5); w = new RandomAccessSparseVector(5); setUpV(v); setUpW(w); doTestGetDistanceSquared(v, w); v = new SequentialAccessSparseVector(5); w = new SequentialAccessSparseVector(5); setUpV(v); setUpW(w); doTestGetDistanceSquared(v, w); }
@Test public void testGetLengthSquared() { Vector v = new DenseVector(5); setUpV(v); doTestGetLengthSquared(v); v = new RandomAccessSparseVector(5); setUpV(v); doTestGetLengthSquared(v); v = new SequentialAccessSparseVector(5); setUpV(v); doTestGetLengthSquared(v); }
@Test public void testAggregation() { Vector v = new DenseVector(5); Vector w = new DenseVector(5); setUpFirstVector(v); setUpSecondVector(w); doTestAggregation(v, w); v = new RandomAccessSparseVector(5); w = new RandomAccessSparseVector(5); setUpFirstVector(v); doTestAggregation(v, w); setUpSecondVector(w); doTestAggregation(w, v); v = new SequentialAccessSparseVector(5); w = new SequentialAccessSparseVector(5); setUpFirstVector(v); doTestAggregation(v, w); setUpSecondVector(w); doTestAggregation(w, v); }
@Test public void createRiIiMaybeTransposed() { Vector ratings = new SequentialAccessSparseVector(3); ratings.setQuick(1, 1.0); ratings.setQuick(3, 3.0); ratings.setQuick(5, 5.0); Matrix riIiMaybeTransposed = AlternatingLeastSquaresSolver.createRiIiMaybeTransposed(ratings); assertEquals(1, riIiMaybeTransposed.numCols(), 1); assertEquals(3, riIiMaybeTransposed.numRows(), 3); assertEquals(1.0, riIiMaybeTransposed.getQuick(0, 0), EPSILON); assertEquals(3.0, riIiMaybeTransposed.getQuick(1, 0), EPSILON); assertEquals(5.0, riIiMaybeTransposed.getQuick(2, 0), EPSILON); }