Java Int2FloatMap.Entry方法代码示例

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
@Override
public TFloatVector filter(float x) {
  SparseFloatVector  vector = new SparseFloatVector(dim);
  vector.setMatrixId(matrixId).setRowId(rowId).setClock(clock);

  ObjectIterator<Int2FloatMap.Entry> iter = hashMap.int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    float value = entry.getFloatValue();
    if (Math.abs(value) > x) {
      vector.set(entry.getIntKey(), value);
    }
  }
  return vector;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
/**
 * Merge this sparse float 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, float[] values, int startPos, int len) {
  try {
    lock.readLock().lock();
    int writeLen = len < hashMap.size() ? len : hashMap.size();
    if (writeLen == 0) {
      return;
    }

    int index = 0;
    for (Int2FloatMap.Entry entry : hashMap.int2FloatEntrySet()) {
      indexes[startPos + index] = entry.getIntKey();
      values[startPos + index] = entry.getFloatValue();
      index++;
      if (index == writeLen) {
        return;
      }
    }
  } finally {
    lock.readLock().unlock();
  }
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private static double predict(final int user, final int itemI,
        @Nonnull final Int2ObjectMap<Int2FloatMap> knnItems, final int excludeIndex,
        @Nonnull final FloatMatrix weightMatrix) {
    final Int2FloatMap kNNu = knnItems.get(user);
    if (kNNu == null) {
        return 0.d;
    }

    double pred = 0.d;
    for (Int2FloatMap.Entry e : Fastutil.fastIterable(kNNu)) {
        final int itemK = e.getIntKey();
        if (itemK == excludeIndex) {
            continue;
        }
        float ruk = e.getFloatValue();
        pred += ruk * weightMatrix.get(itemI, itemK, 0.d);
    }
    return pred;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
@Override
public long nonZeroNumber() {
  long ret = 0;

  if (hashMap != null) {
    ObjectIterator<Int2FloatMap.Entry> iter = this.hashMap.int2FloatEntrySet().fastIterator();
    while (iter.hasNext()) {
      if (iter.next().getFloatValue() != 0)
        ret++;
    }
  }
  return ret;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private SparseDoubleVector plusBy(SparseFloatVector other) {
  resize(other.size());
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    this.hashMap.addTo(entry.getIntKey(), entry.getFloatValue());
  }
  return this;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private TVector plus(SparseFloatVector other) {
  SparseFloatVector newVector = (SparseFloatVector) this.clone();
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().fastIterator();

  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    newVector.hashMap.addTo(entry.getIntKey(), entry.getFloatValue());
  }

  return newVector;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private TVector plusBy(SparseFloatVector other) {
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    this.hashMap.addTo(entry.getIntKey(), entry.getFloatValue());
  }
  return this;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
@Override
public double squaredNorm() {
  ObjectIterator<Int2FloatMap.Entry> iter = hashMap.int2FloatEntrySet().iterator();
  double sum = 0;
  while (iter.hasNext()) {
    float v = iter.next().getFloatValue();
    sum += v * v;
  }
  return sum;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
@Override
public TFloatVector times(float x) {
  SparseFloatVector vector = new SparseFloatVector(this.dim);

  ObjectIterator<Int2FloatMap.Entry> iter = this.hashMap.int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    vector.hashMap.put(entry.getIntKey(), x * entry.getFloatValue());
  }

  return vector;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
@Override
public TFloatVector timesBy(float x) {
  ObjectIterator<Int2FloatMap.Entry> iter = this.hashMap.int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    this.hashMap.put(entry.getIntKey(), x * entry.getFloatValue());
  }

  return this;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private double dot(SparseFloatVector other) {
  double ret = 0.0;
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().fastIterator();
  while (iter.hasNext()) {
    Int2FloatMap.Entry entry = iter.next();
    ret += values[entry.getIntKey()] * entry.getFloatValue();
  }
  return ret;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private TFloatVector plus(SparseFloatVector other) {
  DenseFloatVector vector = new DenseFloatVector(this);
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    vector.values[entry.getIntKey()] += entry.getFloatValue();
  }
  return vector;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private TFloatVector plusBy(SparseFloatVector other) {
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().fastIterator();
  while (iter.hasNext()) {
    Int2FloatMap.Entry entry = iter.next();
    values[entry.getIntKey()] += entry.getFloatValue();
  }

  return this;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
private TIntDoubleVector plus(SparseFloatVector other, double x) {
  DenseDoubleVector vector = this.clone();
  ObjectIterator<Int2FloatMap.Entry> iter = other.hashMap.int2FloatEntrySet().iterator();
  Int2FloatMap.Entry entry = null;
  while(iter.hasNext()) {
    entry = iter.next();
    vector.values[entry.getIntKey()] += entry.getFloatValue() * x;
  }
  return vector;
}
 

import it.unimi.dsi.fastutil.ints.Int2FloatMap; //导入方法依赖的package包/类
@Override public void serialize(ByteBuf buf) {
  super.serialize(buf);
  buf.writeInt(split.size());
  LOG.debug("double size = " + split.size());

  ObjectIterator<Int2FloatMap.Entry> iter =
    split.getIndexToValueMap().int2FloatEntrySet().fastIterator();
  Int2FloatMap.Entry entry = null;
  while (iter.hasNext()) {
    entry = iter.next();
    buf.writeInt(entry.getIntKey());
    buf.writeFloat(entry.getFloatValue());
  }
}