@Override public Vector like(int cardinality) { return new RandomAccessSparseVector(cardinality); }
/** * Return an empty vector of the same underlying class as the receiver * * @return a Vector */ @Override public Vector like() { return new RandomAccessSparseVector(size()); }
@Override Vector generateTestVector(int cardinality) { return new RandomAccessSparseVector(cardinality); }
@Override public Vector like(int cardinality) { return new RandomAccessSparseVector(cardinality, values.size()); }
@Override public void setQuick(int row, int column, double value) { if (columnVectors[column] == null) { columnVectors[column] = new RandomAccessSparseVector(rowSize()); } columnVectors[column].setQuick(row, value); }
/** * Copy the vector for fast operations. * * @return a Vector */ @Override protected Vector createOptimizedCopy() { return new RandomAccessSparseVector(size()).assign(this); }
@Override public RandomAccessSparseVector clone() { return new RandomAccessSparseVector(size(), values.clone()); }
@Test public void testSparseVector() { Vector vec1 = new RandomAccessSparseVector(3); Vector vec2 = new RandomAccessSparseVector(3); doTestVectors(vec1, vec2); }
@Test public void testIteratorRasv() { testIterator(new RandomAccessSparseVector(99)); testEmptyAllIterator(new RandomAccessSparseVector(0)); testExample1NonZeroIterator(new RandomAccessSparseVector(13)); }
@Override public void setQuick(int row, int column, double value) { Vector r = rowVectors.get(row); if (r == null) { r = new RandomAccessSparseVector(columnSize()); rowVectors.put(row, r); } r.setQuick(column, value); }
@Override public RandomAccessSparseVector vectorToTest(int size) { RandomAccessSparseVector r = new RandomAccessSparseVector(size); Random gen = RandomUtils.getRandom(); for (int i = 0; i < 3; i++) { r.set(gen.nextInt(r.size()), gen.nextGaussian()); } return r; }
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(); } }
@Override public Vector viewRow(int row) { if (row < 0 || row >= rowSize()) { throw new IndexException(row, rowSize()); } Vector res = rowVectors.get(row); if (res == null) { res = new RandomAccessSparseVector(columnSize()); rowVectors.put(row, res); } return res; }
@Test @Repeat(iterations = 20) public void testRandomAccessSparseVectorWritable() throws Exception { Vector v = new RandomAccessSparseVector(MAX_VECTOR_SIZE); createRandom(v); doTestVectorWritableEquals(v); }
@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 testSparseDoubleVectorInt() { Vector val = new RandomAccessSparseVector(4); assertEquals("size", 4, val.size()); for (int i = 0; i < 4; i++) { assertEquals("get [" + i + ']', 0.0, val.get(i), EPSILON); } }
@Test public void createRiIiMaybeTransposedExceptionOnNonSequentialVector() { Vector ratings = new RandomAccessSparseVector(3); ratings.setQuick(1, 1.0); ratings.setQuick(3, 3.0); ratings.setQuick(5, 5.0); try { AlternatingLeastSquaresSolver.createRiIiMaybeTransposed(ratings); fail(); } catch (IllegalArgumentException e) {} }
@Test public void testGetDistanceSquared() { Vector other = new RandomAccessSparseVector(test.size()); other.set(1, -2); other.set(2, -5); other.set(3, -9); other.set(4, 1); double expected = test.minus(other).getLengthSquared(); assertTrue("a.getDistanceSquared(b) != a.minus(b).getLengthSquared", Math.abs(expected - test.getDistanceSquared(other)) < 10.0E-7); }
@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 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); }