Java DoubleIterator类代码示例

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
@Override
public void truncateTo(int minimumNumberOfElementsToKeep) {
	if (m.size() < minimumNumberOfElementsToKeep)
		return;
	
	DoubleHeapPriorityQueue heap = new DoubleHeapPriorityQueue();
	
	DoubleIterator values = values();
	while (values.hasNext()) {
			heap.enqueue(Math.abs(values.nextDouble()));
			if (heap.size() > minimumNumberOfElementsToKeep)
				heap.dequeueDouble();
		}
	
	double threshold = heap.dequeueDouble();
	
	DoubleIterator iterator = m.values().iterator();
	while (iterator.hasNext()) {
		if (Math.abs(iterator.nextDouble()) < threshold)
			iterator.remove();
	}
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
@Override
public DoubleIterator values() {
	return new DoubleIterator() {
		private int i = size - 1, j = size - 1;
		public Double next() { return Double.valueOf(nextDouble()); }
		public int skip(int n) { throw new UnsupportedOperationException(); }
		public void remove() { throw new UnsupportedOperationException(); }
		
		public double nextDouble() {
			i--;
			if (i < 0) {
				i = size - 1;
				j--;
			}
			return m[i][j];
		}
		public boolean hasNext() {
			return i != 0 || j != 0;
		}
		
	};
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
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;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
private double[] getProductArray(int uidx) {
    double[] productArray = new double[data.numUsers()];

    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()) {
                productArray[vidxs.nextInt()] += iv * vvs.nextDouble();
            }
        }
    } else {
        data.getUidxPreferences(uidx)
                .forEach(ip -> data.getIidxPreferences(ip.v1)
                        .forEach(up -> productArray[up.v1] += ip.v2 * up.v2));
    }

    productArray[uidx] = 0.0;

    return productArray;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
private double getNorm2(int uidx) {
    if (data.useIteratorsPreferentially()) {
        DoubleIterator ivs = data.getUidxVs(uidx);
        double sum = 0;
        while (ivs.hasNext()) {
            double iv = ivs.nextDouble();
            sum += iv * iv;
        }
        return sum;
    } else {
        return data.getUidxPreferences(uidx)
                .mapToDouble(IdxPref::v2)
                .map(x -> x * x)
                .sum();
    }
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
@Nullable
public static <T> T getWeightedRandomReversed(Random random, Double2ObjectMap<T> choices)
{
    double i = 0;
    DoubleSet doubles = choices.keySet();
    for (DoubleIterator iterator = doubles.iterator(); iterator.hasNext(); )
    {
        double x = iterator.nextDouble();
        i += x;
    }
    i = getRandomDouble(random, 0, i);
    for (Double2ObjectMap.Entry<T> entry : choices.double2ObjectEntrySet())
    {
        i -= entry.getDoubleKey();
        if (i < 0)
        {
            return entry.getValue();
        }
    }
    return null;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
@Nullable
public static <T> T getWeightedRandom(Random random, Object2DoubleMap<T> choices)
{
    double i = 0;
    DoubleCollection doubles = choices.values();
    for (DoubleIterator iterator = doubles.iterator(); iterator.hasNext(); )
    {
        double x = iterator.nextDouble();
        i += x;
    }
    i = getRandomDouble(random, 0, i);
    for (Object2DoubleMap.Entry<T> entry : choices.object2DoubleEntrySet())
    {
        i -= entry.getDoubleValue();
        if (i < 0)
        {
            return entry.getKey();
        }
    }
    return null;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
@Override
public Iterator<Edge<LongWritable, DoubleWritable>> iterator() {
  // Returns an iterator that reuses objects.
  return new UnmodifiableIterator<Edge<LongWritable, DoubleWritable>>() {
    /** Wrapped neighbors iterator. */
    private LongIterator neighborsIt = neighbors.iterator();
    /** Wrapped edge values iterator. */
    private DoubleIterator edgeValuesIt = edgeValues.iterator();
    /** Representative edge object. */
    private Edge<LongWritable, DoubleWritable> representativeEdge =
        EdgeFactory.create(new LongWritable(), new DoubleWritable());

    @Override
    public boolean hasNext() {
      return neighborsIt.hasNext();
    }

    @Override
    public Edge<LongWritable, DoubleWritable> next() {
      representativeEdge.getTargetVertexId().set(neighborsIt.nextLong());
      representativeEdge.getValue().set(edgeValuesIt.nextDouble());
      return representativeEdge;
    }
  };
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
@Override
public boolean isBad() {
	final DoubleIterator iterator = values.values().iterator();
	while (iterator.hasNext()) {
		final double value = iterator.nextDouble();
		if (Double.isNaN(value) || Double.isInfinite(value)) {
			return true;
		}
	}
	return false;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
private double cosineProduct(Object2DoubleMap<String> vector1, Object2DoubleMap<String> vector2) {
    double aa = 0, bb = 0, ab = 0;
    for(Object2DoubleMap.Entry<String> e : vector1.object2DoubleEntrySet()) {
        aa += e.getDoubleValue() * e.getDoubleValue();
        ab += e.getDoubleValue() * vector2.getDouble(e.getKey());
    }
    DoubleIterator di  = vector2.values().iterator();
    while(di.hasNext()) {
        double d = di.nextDouble();
        bb +=  d * d;
    }
    return ab / Math.sqrt(aa * bb);
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
public Selection isEqualTo(DoubleColumn d) {
    Selection results = new BitmapBackedSelection();
    int i = 0;
    DoubleIterator doubleIterator = d.iterator();
    for (double doubles : data) {
        if (doubles == doubleIterator.nextDouble()) {
            results.add(i);
        }
        i++;
    }
    return results;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
public Selection isGreaterThan(DoubleColumn d) {
    Selection results = new BitmapBackedSelection();
    int i = 0;
    DoubleIterator doubleIterator = d.iterator();
    for (double doubles : data) {
        if (doubles > doubleIterator.nextDouble()) {
            results.add(i);
        }
        i++;
    }
    return results;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
public Selection isLessThan(DoubleColumn d) {
    Selection results = new BitmapBackedSelection();
    int i = 0;
    DoubleIterator doubleIterator = d.iterator();
    for (double doubles : data) {
        if (doubles < doubleIterator.nextDouble()) {
            results.add(i);
        }
        i++;
    }
    return results;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
public int numberOfNonZeroEntries() {
	int n = 0;
	DoubleIterator values = values();
	while (values.hasNext())
		if (values.nextDouble() != 0)
			n++;
	return n;
}
 

import it.unimi.dsi.fastutil.doubles.DoubleIterator; //导入依赖的package包/类
public double maxNorm() {
	double max = 0;
	DoubleIterator values = values();
	while (values.hasNext())
		max = Math.max(max, Math.abs(values.nextDouble()));
	return max;
}