@Override public Iterable<Element> all() { return delegate.all(); }
@Override public Iterable<Element> all() { return delegate.all(); }
private AllIterator() { it = vector.all().iterator(); }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { Iterator<Vector.Element> xi = x.all().iterator(); Iterator<Vector.Element> yi = y.all().iterator(); while (xi.hasNext() && yi.hasNext()) { Element xe = xi.next(); x.setQuick(xe.index(), f.apply(xe.get(), yi.next().get())); } return x; } }
public static void writeMatrix(File f, Matrix m) throws IOException { Preconditions.checkArgument(f.canWrite(), "Can't write to output file"); FileOutputStream fos = new FileOutputStream(f); try { ByteBuffer buf = ByteBuffer.allocate(m.columnSize() * 8); for (MatrixSlice row : m) { buf.clear(); for (Vector.Element element : row.vector().all()) { buf.putDouble(element.get()); } buf.flip(); fos.write(buf.array()); } } finally { fos.close(); } }
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> xi = x.all().iterator(); Iterator<Vector.Element> yi = y.all().iterator(); boolean validResult = false; double result = 0; while (xi.hasNext() && yi.hasNext()) { Vector.Element xe = xi.next(); double thisResult = fc.apply(xe.get(), yi.next().get()); if (validResult) { result = fa.apply(result, thisResult); } else { result = thisResult; validResult = true; } } return result; } }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { Iterator<Vector.Element> xi = x.all().iterator(); Iterator<Vector.Element> yi = y.all().iterator(); OrderedIntDoubleMapping updates = new OrderedIntDoubleMapping(false); while (xi.hasNext() && yi.hasNext()) { Element xe = xi.next(); updates.set(xe.index(), f.apply(xe.get(), yi.next().get())); } x.mergeUpdates(updates); return x; } }
private Matrix columnVectorAsMatrix(Vector v) { double[][] matrix = new double[numFeatures][1]; for (Vector.Element e : v.all()) { matrix[e.index()][0] = e.get(); } return new DenseMatrix(matrix, true); }
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> yi = y.all().iterator(); boolean validResult = false; double result = 0; while (yi.hasNext()) { Vector.Element ye = yi.next(); double thisResult = fc.apply(x.getQuick(ye.index()), ye.get()); if (validResult) { result = fa.apply(result, thisResult); } else { result = thisResult; validResult = true; } } return result; } }
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> xi = x.all().iterator(); boolean validResult = false; double result = 0; while (xi.hasNext()) { Vector.Element xe = xi.next(); double thisResult = fc.apply(xe.get(), y.getQuick(xe.index())); if (validResult) { result = fa.apply(result, thisResult); } else { result = thisResult; validResult = true; } } return result; } }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { for (Element xe : x.all()) { x.setQuick(xe.index(), f.apply(xe.get(), y.getQuick(xe.index()))); } return x; } }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { for (Element ye : y.all()) { x.setQuick(ye.index(), f.apply(x.getQuick(ye.index()), ye.get())); } return x; } }
/** 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); } }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { OrderedIntDoubleMapping updates = new OrderedIntDoubleMapping(false); for (Element xe : x.all()) { updates.set(xe.index(), f.apply(xe.get(), y.getQuick(xe.index()))); } x.mergeUpdates(updates); return x; } }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { OrderedIntDoubleMapping updates = new OrderedIntDoubleMapping(false); for (Element ye : y.all()) { updates.set(ye.index(), f.apply(x.getQuick(ye.index()), ye.get())); } x.mergeUpdates(updates); return x; } }
@Override public Matrix assignColumn(int column, Vector other) { if (columnSize() != other.size()) { throw new IndexException(columnSize(), other.size()); } if (other.viewPart(column + 1, other.size() - column - 1).norm(1) > 1.0e-14) { throw new IllegalArgumentException("Cannot set lower portion of triangular matrix to non-zero"); } for (Vector.Element element : other.viewPart(0, column).all()) { setQuick(element.index(), column, element.get()); } return this; }
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); } }
@Test public void testIterators() { final T v0 = vectorToTest(20); double sum = 0; int elements = 0; int nonZero = 0; for (Element element : v0.all()) { elements++; sum += element.get(); if (element.get() != 0) { nonZero++; } } int nonZeroIterated = Iterables.size(v0.nonZeroes()); assertEquals(20, elements); assertEquals(v0.size(), elements); assertEquals(nonZeroIterated, nonZero); assertEquals(v0.zSum(), sum, 0); }
@Test public void testIteratorSet() { Vector clone = test.clone(); for (Element e : clone.nonZeroes()) { e.set(e.get() * 2.0); } for (Element e : clone.nonZeroes()) { assertEquals(test.get(e.index()) * 2.0, e.get(), EPSILON); } clone = test.clone(); for (Element e : clone.all()) { e.set(e.get() * 2.0); } for (Element e : clone.all()) { assertEquals(test.get(e.index()) * 2.0, e.get(), EPSILON); } }
@Test public void testEigen() { double[] evals = {0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 2.0e-7, 0.0, 0.0, -2.0e-7, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0}; int i = 0; Matrix a = new DenseMatrix(4, 4); for (MatrixSlice row : a) { for (Vector.Element element : row.vector().all()) { element.set(evals[i++]); } } EigenDecomposition eig = new EigenDecomposition(a); Matrix d = eig.getD(); Matrix v = eig.getV(); check("EigenvalueDecomposition (nonsymmetric)...", a.times(v), v.times(d)); }