private double dot(SparseDoubleVector other) { double ret = 0.0; Int2DoubleOpenHashMap smallMap = this.hashMap; Int2DoubleOpenHashMap largeMap = other.hashMap; if (smallMap.size() > largeMap.size()) { smallMap = other.hashMap; largeMap = this.hashMap; } ObjectIterator<Int2DoubleMap.Entry> iter = smallMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); if (largeMap.containsKey(entry.getIntKey())) { ret += entry.getDoubleValue() * largeMap.get(entry.getIntKey()); } } return ret; }
@Override public TIntDoubleVector filter(double x) { Int2DoubleOpenHashMap newMap = new Int2DoubleOpenHashMap(); ObjectIterator<Int2DoubleMap.Entry> iter = hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); double value = entry.getDoubleValue(); if (Math.abs(value) > x) { newMap.put(entry.getIntKey(), value); } } SparseDoubleVector vector = new SparseDoubleVector(dim, newMap); vector.setRowId(rowId).setMatrixId(matrixId).setClock(clock); return vector; }
@Override public void writeTo(DataOutputStream output) throws IOException { try { lock.readLock().lock(); super.writeTo(output); output.writeInt(hashMap.size()); ObjectIterator<Int2DoubleMap.Entry> iter = hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); output.writeInt(entry.getIntKey()); output.writeDouble(entry.getDoubleValue()); } } finally { lock.readLock().unlock(); } }
@Override public void serialize(ByteBuf buf) { try { lock.readLock().lock(); super.serialize(buf); buf.writeInt(hashMap.size()); ObjectIterator<Int2DoubleMap.Entry> iter = hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); buf.writeInt(entry.getIntKey()); buf.writeDouble(entry.getDoubleValue()); } } finally { lock.readLock().unlock(); } }
/** * Merge this sparse double vector split to a index/value array * @param indexes index array * @param values value array * @param startPos write start position of the index/value array * @param len write length */ public void mergeTo(int[] indexes, double[] values, int startPos, int len) { try { lock.readLock().lock(); int writeLen = len < hashMap.size() ? len : hashMap.size(); if (writeLen == 0) { return; } int index = 0; ObjectIterator<Int2DoubleMap.Entry> iter = hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); indexes[startPos + index] = entry.getIntKey(); values[startPos + index] = entry.getDoubleValue(); index++; if (index == writeLen) { return; } } } finally { lock.readLock().unlock(); } }
/** * Calculate the cosine of two vectors * @param _v1 Vector 1 * @param _v2 Vector 2 * @return Sum(x*y)/(norm(x)*norm(y)) */ public static double cosine(Vector _v1, Vector _v2) { final Vector v1 = _v1.size() < _v2.size() ? _v1 : _v2; final Vector v2 = _v1.size() < _v2.size() ? _v2 : _v1; if(v1.len() != v2.len()) throw new LinearAlgebraException(String.format("Vector lengths do not match %d <-> %d", v1.len(), v2.len())); double aa = 0, ab = 0; for(Int2DoubleMap.Entry s : v1.sparseEntrySet()) { aa += s.getDoubleValue()*s.getDoubleValue(); ab += s.getDoubleValue()*v2.getDouble(s.getIntKey()); } final double bnorm = v2.norm(); if(aa == 0 && bnorm == 0) { return 0.0; } else { return ab / Math.sqrt(aa) / bnorm; } }
public static void truncateMapByHighestValue(Int2DoubleMap map, int howMany) { if (howMany >= map.size()) return; double[] values = map.values().toDoubleArray(); Arrays.sort(values); // not best strategy, i know org.apache.commons.lang.ArrayUtils.reverse(values); double threshold = values[howMany+1]; ObjectIterator<Entry> mapIterator = map.int2DoubleEntrySet().iterator(); int inserted = 0; while (mapIterator.hasNext()) if (mapIterator.next().getDoubleValue() < threshold || inserted >= howMany) mapIterator.remove(); else inserted++; }
public void saveComparisons(File f) throws IOException { final Writer out = new FileWriter(f); LOGGER.info("Computing and saving scores..."); for (int node : groundtruth.queries()) { Int2DoubleMap[] scorersResults = new Int2DoubleMap[scorers.length]; for (int i = 0; i < scorers.length; i++) scorersResults[i] = scorers[i].scores(node); for (int succ : groundtruth.getEvaluatedDocs(node)) { StringBuilder row = new StringBuilder(); for (Int2DoubleMap scorersResult : scorersResults) row.append(scorersResult.get(succ) + "\t"); row.append(groundtruth.getRelevance(node, succ) + "\n"); out.write(row.toString()); } } LOGGER.info("Done."); out.close(); }
private Int2DoubleMap getProductMap(int uidx) { Int2DoubleOpenHashMap productMap = new Int2DoubleOpenHashMap(); productMap.defaultReturnValue(0.0); if (data.useIteratorsPreferentially()) { IntIterator iidxs = data.getUidxIidxs(uidx); DoubleIterator ivs = data.getUidxVs(uidx); while (iidxs.hasNext()) { int iidx = iidxs.nextInt(); double iv = ivs.nextDouble(); IntIterator vidxs = data.getIidxUidxs(iidx); DoubleIterator vvs = data.getIidxVs(iidx); while (vidxs.hasNext()) { productMap.addTo(vidxs.nextInt(), iv * vvs.nextDouble()); } } } else { data.getUidxPreferences(uidx) .forEach(ip -> data.getIidxPreferences(ip.v1) .forEach(up -> productMap.addTo(up.v1, ip.v2 * up.v2))); } productMap.remove(uidx); return productMap; }
@Override public FastRecommendation getRecommendation(int uidx, int maxLength, IntPredicate filter) { if (uidx == -1) { return new FastRecommendation(uidx, new ArrayList<>(0)); } Int2DoubleMap scoresMap = getScoresMap(uidx); final IntDoubleTopN topN = new IntDoubleTopN(min(maxLength, scoresMap.size())); scoresMap.int2DoubleEntrySet().forEach(e -> { int iidx = e.getIntKey(); double score = e.getDoubleValue(); if (filter.test(iidx)) { topN.add(iidx, score); } }); topN.sort(); List<Tuple2id> items = topN.reverseStream() .collect(toList()); return new FastRecommendation(uidx, items); }
@Override public SparseFloatVector newNumberVector(Int2DoubleOpenHashMap dvalues, int maxdim) { int[] indexes = new int[dvalues.size()]; float[] values = new float[dvalues.size()]; // Import and sort the indexes ObjectIterator<Int2DoubleMap.Entry> iter = dvalues.int2DoubleEntrySet().fastIterator(); for(int i = 0; iter.hasNext(); i++) { indexes[i] = iter.next().getIntKey(); } Arrays.sort(indexes); // Import the values accordingly for(int i = 0; i < dvalues.size(); i++) { values[i] = (float) dvalues.get(indexes[i]); } return new SparseFloatVector(indexes, values, maxdim); }
@Test public void testIterationOrder() { Vector v = new Vector(); v.put(0, 0); v.put(1, 1); v.put(2, 2); v.put(3, 3); v.put(4, 4); BidirectionalIterator<Int2DoubleMap.Entry> it = v.int2DoubleEntrySet().fastIterator(v.int2DoubleEntrySet().last()); // for (int i = 0; i < v.size(); i++) { int i = 4; while (it.hasPrevious()) { Entry e = it.previous(); int lastKey = e.getIntKey(); double lastValue = e.getDoubleValue(); assertEquals(i, lastKey); assertEquals(i, lastValue, Double.MIN_NORMAL); i--; } assertEquals(5, v.size()); assertEquals(0, v.int2DoubleEntrySet().first().getIntKey()); assertEquals(4, v.int2DoubleEntrySet().last().getIntKey()); }
private double dot(SparseDoubleVector other) { double ret = 0.0; ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); while (iter.hasNext()) { Int2DoubleMap.Entry entry = iter.next(); ret += values[entry.getIntKey()] * entry.getDoubleValue(); } return ret; }
private TVector plus(SparseDoubleVector other) { DenseFloatVector vector = new DenseFloatVector(dim); System.arraycopy(values, 0, vector.values, 0, dim); ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); while (iter.hasNext()) { Int2DoubleMap.Entry entry = iter.next(); vector.values[entry.getIntKey()] += (float) entry.getDoubleValue(); } return vector; }
private TFloatVector plusBy(SparseDoubleVector other) { ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); while (iter.hasNext()) { Int2DoubleMap.Entry entry = iter.next(); values[entry.getIntKey()] += (float) entry.getDoubleValue(); } return this; }
private TFloatVector plusBy(SparseDoubleVector other, float x) { float fx = (float) x; ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); while (iter.hasNext()) { Int2DoubleMap.Entry entry = iter.next(); values[entry.getIntKey()] += (float) entry.getDoubleValue() * fx; } return this; }
private TVector plusBy(SparseDoubleVector other) { ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while(iter.hasNext()) { entry = iter.next(); plusBy(entry.getIntKey(), entry.getDoubleValue()); } return this; }
private TVector plusBy(SparseDoubleVector other, double x) { ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while(iter.hasNext()) { entry = iter.next(); plusBy(entry.getIntKey(), entry.getDoubleValue() * x); } return this; }
private double dot(SparseDoubleVector other) { double dotValue = 0.0; ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while(iter.hasNext()) { entry = iter.next(); dotValue += entry.getDoubleValue() * get(entry.getIntKey()); } return dotValue; }
private TIntDoubleVector plus(SparseDoubleVector other, double x) { DenseDoubleVector vector = this.clone(); ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().iterator(); Int2DoubleMap.Entry entry = null; while(iter.hasNext()) { entry = iter.next(); vector.values[entry.getIntKey()] += entry.getDoubleValue() * x; } return vector; }
private TIntDoubleVector plus(SparseDoubleVector other) { DenseDoubleVector vector = this.clone(); ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vector.values[entry.getIntKey()] += entry.getDoubleValue(); } return vector; }
private TIntDoubleVector plusBy(SparseDoubleVector other, double x) { ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); while (iter.hasNext()) { Int2DoubleMap.Entry entry = iter.next(); values[entry.getIntKey()] += entry.getDoubleValue() * x; } return this; }
private TIntDoubleVector plusBy(SparseDoubleVector other) { ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); values[entry.getIntKey()] += entry.getDoubleValue(); } return this; }
@Override public double sum() { double ret = 0.0; ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry; while (iter.hasNext()) { entry = iter.next(); ret += entry.getDoubleValue(); } return ret; }
@Override public TIntDoubleVector elemUpdate(IntDoubleElemUpdater updater, ElemUpdateParam param) { ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry; while (iter.hasNext()) { entry = iter.next(); updater.action(entry.getIntKey(), entry.getDoubleValue(), param); } return this; }
private double dot(DenseDoubleVector other) { double ret = 0.0; ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); ret += entry.getDoubleValue() * other.values[entry.getIntKey()]; } return ret; }
private double dot(DenseFloatVector other) { double ret = 0.0; ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); ret += entry.getDoubleValue() * other.values[entry.getIntKey()]; } return ret; }
@Override public long nonZeroNumber() { long ret = 0; if (hashMap != null) { ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); while (iter.hasNext()) { if (iter.next().getDoubleValue() != 0) { ret++; } } } return ret; }
private DenseDoubleVector plus(DenseDoubleVector other, double x) { DenseDoubleVector vec = new DenseDoubleVector(other); vec.timesBy(x); ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vec.plusBy(entry.getIntKey(), entry.getDoubleValue()); } return vec; }
private SparseDoubleVector plus(SparseDoubleVector other, double x) { SparseDoubleVector vector = (SparseDoubleVector) this.clone(); ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vector.hashMap.addTo(entry.getIntKey(), entry.getDoubleValue() * x); } return vector; }
private DenseDoubleVector plus(DenseFloatVector other, double x) { DenseDoubleVector vector = new DenseDoubleVector(dim); vector.plusBy(other); ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vector.values[entry.getIntKey()] += entry.getDoubleValue() * x; } return vector; }
public TIntDoubleVector plus(DenseDoubleVector other) { DenseDoubleVector vec = new DenseDoubleVector(other); ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vec.plusBy(entry.getIntKey(), entry.getDoubleValue()); } return vec; }
private SparseDoubleVector plus(SparseDoubleVector other) { SparseDoubleVector vector = (SparseDoubleVector) this.clone(); ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vector.hashMap.addTo(entry.getIntKey(), entry.getDoubleValue()); } return vector; }
private DenseDoubleVector plus(DenseFloatVector other) { DenseDoubleVector vector = new DenseDoubleVector(dim); vector.plusBy(other); ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vector.values[entry.getIntKey()] += entry.getDoubleValue(); } return vector; }
private SparseDoubleVector plusBy(SparseDoubleVector other, double x) { resize(other.size()); ObjectIterator<Int2DoubleMap.Entry> iter = other.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); this.hashMap.addTo(entry.getIntKey(), entry.getDoubleValue() * x); } return this; }
@Override public TIntDoubleVector times(double x) { SparseDoubleVector vector = (SparseDoubleVector) this.clone(); ObjectIterator<Int2DoubleMap.Entry> iter = vector.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); vector.hashMap.put(entry.getIntKey(), entry.getDoubleValue() * x); } return vector; }
@Override public TIntDoubleVector timesBy(double x) { ObjectIterator<Int2DoubleMap.Entry> iter = this.hashMap.int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); this.hashMap.put(entry.getIntKey(), entry.getDoubleValue() * x); } return this; }
@Override public double squaredNorm() { ObjectIterator<Int2DoubleMap.Entry> iter = hashMap.int2DoubleEntrySet().iterator(); double sum = 0; while (iter.hasNext()) { double v = iter.next().getDoubleValue(); sum += v * v; } return sum; }
@Override public double norm() { ObjectIterator<Int2DoubleMap.Entry> iter = hashMap.int2DoubleEntrySet().iterator(); double sum = 0; while (iter.hasNext()) { sum += Math.abs(iter.next().getDoubleValue()); } return sum; }
@Override public void serialize(ByteBuf buf) { super.serialize(buf); buf.writeInt(split.size()); ObjectIterator<Int2DoubleMap.Entry> iter = split.getIndexToValueMap().int2DoubleEntrySet().fastIterator(); Int2DoubleMap.Entry entry = null; while (iter.hasNext()) { entry = iter.next(); buf.writeInt(entry.getIntKey()); buf.writeDouble(entry.getDoubleValue()); } }