Refine search
public Vector logNormalize(double power, double normLength) { // we can special case certain powers if (Double.isInfinite(power) || power <= 1.0) { throw new IllegalArgumentException("Power must be > 1 and < infinity"); } else { double denominator = normLength * Math.log(power); Vector result = createOptimizedCopy(); for (Element element : result.nonZeroes()) { element.set(Math.log1p(element.get()) / denominator); } return result; } }
public static Vector mergeToVector(Iterator<VectorWritable> vectors) { Vector accumulator = vectors.next().get(); while (vectors.hasNext()) { VectorWritable v = vectors.next(); if (v != null) { for (Element nonZeroElement : v.get().nonZeroes()) { accumulator.setQuick(nonZeroElement.index(), nonZeroElement.get()); } } } return accumulator; }
static Matrix createRiIiMaybeTransposed(Vector ratingVector) { Preconditions.checkArgument(ratingVector.isSequentialAccess(), "Ratings should be iterable in Index or Sequential Order"); double[][] RiIiMaybeTransposed = new double[ratingVector.getNumNondefaultElements()][1]; int index = 0; for (Vector.Element elem : ratingVector.nonZeroes()) { RiIiMaybeTransposed[index++][0] = elem.get(); } return new DenseMatrix(RiIiMaybeTransposed, true); } }
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> yi = y.nonZeroes().iterator(); if (!yi.hasNext()) { return 0; } Vector.Element ye = yi.next(); double result = fc.apply(x.getQuick(ye.index()), ye.get()); while (yi.hasNext()) { ye = yi.next(); result = fa.apply(result, fc.apply(x.getQuick(ye.index()), ye.get())); } return result; } }
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> xi = x.nonZeroes().iterator(); if (!xi.hasNext()) { return 0; } Vector.Element xe = xi.next(); double result = fc.apply(xe.get(), y.getQuick(xe.index())); while (xi.hasNext()) { xe = xi.next(); result = fa.apply(result, fc.apply(xe.get(), y.getQuick(xe.index()))); } return result; } }
@Override public Vector assign(Vector x, Vector y, DoubleDoubleFunction f) { Iterator<Vector.Element> xi = x.nonZeroes().iterator(); Iterator<Vector.Element> yi = y.nonZeroes().iterator(); Vector.Element xe = null; Vector.Element ye = null; if (xe.index() == ye.index()) { xe.set(f.apply(xe.get(), ye.get())); advanceThis = true; advanceThat = true; } else { if (xe.index() < ye.index()) { // f(x, 0) = 0 advanceThis = true; advanceThat = false;
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> xi = x.nonZeroes().iterator(); Iterator<Vector.Element> yi = y.nonZeroes().iterator(); Vector.Element xe = null; Vector.Element ye = null; if (xe.index() == ye.index()) { double thisResult = fc.apply(xe.get(), ye.get()); if (validResult) { result = fa.apply(result, thisResult); advanceThat = true; } else { if (xe.index() < ye.index()) { // f(x, 0) = 0 advanceThis = true; advanceThat = false;
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { OpenIntHashSet visited = new OpenIntHashSet(); Iterator<Vector.Element> xi = x.nonZeroes().iterator(); boolean validResult = false; double result = 0; while (xi.hasNext()) { Vector.Element xe = xi.next(); thisResult = fc.apply(xe.get(), y.getQuick(xe.index())); if (validResult) { result = fa.apply(result, thisResult); validResult = true; visited.add(xe.index()); Iterator<Vector.Element> yi = y.nonZeroes().iterator(); while (yi.hasNext()) { Vector.Element ye = yi.next(); if (!visited.contains(ye.index())) { thisResult = fc.apply(x.getQuick(ye.index()), ye.get()); if (validResult) { result = fa.apply(result, thisResult);
for (Element element : vector.all()) { if (laxPrecision) { out.writeFloat((float) element.get()); } else { out.writeDouble(element.get()); Iterator<Element> iter = vector.nonZeroes().iterator(); if (sequential) { int lastIndex = 0; while (iter.hasNext()) { Element element = iter.next(); if (element.get() == 0) { continue; int thisIndex = element.index(); Varint.writeUnsignedVarInt(element.index(), out); if (laxPrecision) { out.writeFloat((float) element.get());
/** Y' Cu p(u) */ private Matrix getYtransponseCuPu(Vector userRatings) { Preconditions.checkArgument(userRatings.isSequentialAccess(), "need sequential access to ratings!"); Vector YtransponseCuPu = new DenseVector(numFeatures); for (Element e : userRatings.nonZeroes()) { YtransponseCuPu.assign(Y.get(e.index()).times(confidence(e.get())), Functions.PLUS); } return columnVectorAsMatrix(YtransponseCuPu); }
@Override public double aggregate(Vector x, Vector y, DoubleDoubleFunction fa, DoubleDoubleFunction fc) { Iterator<Vector.Element> xi = x.nonZeroes().iterator(); Iterator<Vector.Element> yi = y.nonZeroes().iterator(); Vector.Element xe = null; Vector.Element ye = null; if (xe.index() == ye.index()) { thisResult = fc.apply(xe.get(), ye.get()); advanceThis = true; advanceThat = true; } else { if (xe.index() < ye.index()) { // f(x, 0) thisResult = fc.apply(xe.get(), 0); advanceThis = true; advanceThat = false;
private int copySortedRandomAccessSparseVector(Vector other) { int elementCount = other.getNumNondefaultElements(); OrderedElement[] sortableElements = new OrderedElement[elementCount]; int s = 0; for (Element e : other.nonZeroes()) { sortableElements[s++] = new OrderedElement(e.index(), e.get()); } Arrays.sort(sortableElements); for (int i = 0; i < sortableElements.length; i++) { values.setIndexAt(i, sortableElements[i].index); values.setValueAt(i, sortableElements[i].value); } values = new OrderedIntDoubleMapping(values.getIndices(), values.getValues(), elementCount); return elementCount; }
public SequentialAccessSparseVector(Vector other) { this(other.size(), other.getNumNondefaultElements()); if (other.isSequentialAccess()) { for (Element e : other.nonZeroes()) { set(e.index(), e.get()); } } else { // If the incoming Vector to copy is random, then adding items // from the Iterator can degrade performance dramatically if // the number of elements is large as this Vector tries to stay // in order as items are added, so it's better to sort the other // Vector's elements by index and then add them to this copySortedRandomAccessSparseVector(other); } }