Java IntSet.size方法代码示例

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
private DebugLocalsChange createLocalsChange(
    Int2ReferenceMap<DebugLocalInfo> ending, Int2ReferenceMap<DebugLocalInfo> starting) {
  if (ending.isEmpty() && starting.isEmpty()) {
    return null;
  }
  if (ending.isEmpty() || starting.isEmpty()) {
    return new DebugLocalsChange(ending, starting);
  }
  IntSet unneeded = new IntArraySet(Math.min(ending.size(), starting.size()));
  for (Entry<DebugLocalInfo> entry : ending.int2ReferenceEntrySet()) {
    if (starting.get(entry.getIntKey()) == entry.getValue()) {
      unneeded.add(entry.getIntKey());
    }
  }
  if (unneeded.size() == ending.size() && unneeded.size() == starting.size()) {
    return null;
  }
  IntIterator iterator = unneeded.iterator();
  while (iterator.hasNext()) {
    int key = iterator.nextInt();
    ending.remove(key);
    starting.remove(key);
  }
  return new DebugLocalsChange(ending, starting);
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
protected void learnNode(int node, IntSet successors ) throws IOException {
	
	for (int successor : successors) {
		classifier.learn(node2cat.get(node), node2cat.get(successor), true);
		anArcHasBeenLearned();
		pl.lightUpdate();
	}
	int nonSucc;
	for (int i = successors.size()-1; i >= 0; i--) {
		do { 
			nonSucc = rnd.nextInt(numNodes);
		} while (successors.contains(nonSucc));
		classifier.learn(node2cat.get(node), node2cat.get(nonSucc), false);
		anArcHasBeenLearned();
		pl.lightUpdate();
	}
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
public int[] createTestingSet(int numOfSamples) {
	numOfSamples = Math.min(numOfSamples, numNodes);

	if (verbose) LOGGER.info("Creating test set with "+numOfSamples+" nodes...");
	if (numOfSamples >= (numNodes/2)) {
		final Random rnd = RandomSingleton.get();
		int[] samples = MathArrays.natural(numNodes);
		IntArrays.shuffle(samples, rnd);
		return IntArrays.trim(samples, numOfSamples);
	} else {
		IntSet set = new IntOpenHashSet();
		while (set.size() < numOfSamples) {
			set.add(rnd.nextInt(numNodes));
		}
		int[] r = set.toIntArray();
		return r;
	}
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
@Override
public double computeForQuery(int query, UnexpectednessScorer retriever) {
	IntSet evaluatedDocs = groundtruth.getEvaluatedDocs(query);
	double R = groundtruth.getRelevants(query).size();
	double N = evaluatedDocs.size() - R;
	double minNR = Math.min(N, R);
	
	int[] retrieved = retriever.results(query);
	
	double bpref = 0, nonRelevantRankedFirst = 0;
	for (int doc : retrieved)
		if (evaluatedDocs.contains(doc)) {
			if (groundtruth.isRelevant(query, doc)) {
				bpref += 1.0 - (nonRelevantRankedFirst / minNR);
			} else {
				if (nonRelevantRankedFirst < R)
					nonRelevantRankedFirst ++;

			}
		}
	
	bpref /= R;
	printResult(this + "\t" + retriever + "\t" + query(query) + "\t" + bpref);
	
	return bpref;
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
int calcRandomHits(int _size, int _seed) {
  IntSet _cache = new IntOpenHashSet();
  IntList _list = new IntArrayList();
  Random _random = new Random(_seed);
  int _hitCnt = 0;
  for (int v : getTrace()) {
    if(_cache.contains(v)) {
      _hitCnt++;
    } else {
      if (_cache.size() == _size) {
        int cnt = _random.nextInt(_cache.size());
        _cache.remove(_list.get(cnt));
        _list.remove(cnt);
      }
      _cache.add(v);
      _list.add(v);
    }
  }
  return _hitCnt;
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
@Override
public int countUnique() {
    IntSet ints = new IntOpenHashSet(size());
    for (int i = 0; i < size(); i++) {
        ints.add(data.getInt(i));
    }
    return ints.size();
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
@Override
public Int2DoubleMap scores(int docI) {
	IntSet successors = successors(docI);
	Int2DoubleMap results = new Int2DoubleOpenHashMap(successors.size());
	IntSet catI = page2cat.get(docI);
	for (int docJ : successors) {
		IntSet catJ = page2cat.get(docJ);
		results.put(docJ, -expectedness(catI, catJ));
	}
	return results;
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
public SummaryStatistics[] computeAll() {
	SummaryStatistics[] results = new SummaryStatistics[retrievers.length];
	for (int i = 0; i < retrievers.length; i++)
		results[i] = new SummaryStatistics();
	
	IntSet queries = groundtruth.queriesWithRelevantDocs();
	
	ProgressLogger pl = new ProgressLogger(LOGGER, "query retrievals");
	pl.expectedUpdates = queries.size() * retrievers.length;
	pl.start("Computing results for each of the " + queries.size() + 
			" queries and "+retrievers.length+ " retrieving algorithms..."  );
	
	for (int query : queries) {
		for (int i = 0; i < retrievers.length; i++) {
			double value = computeForQuery(query, retrievers[i]);
			if (Double.isNaN(value))
				continue;
			results[i].addValue(value);
			pl.update();
		}
	}
	
	pl.done();
	
	long nItems = results[0].getN();
	for (SummaryStatistics s : results)
		if (s.getN() != nItems)
			throw new IllegalStateException("The measure returned NaN differently for different algorithms.");
	
	print(retrievers, results);
	
	return results;
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
public void check(int node) {
	IntSet consideredSuccessors = evaluations.getEvaluatedDocs(node);
	IntSet unmatchedSuccessors = new IntOpenHashSet(consideredSuccessors);
	
	int howMany = (int) (graph.outdegree(node) * ALPHA);
	
	for (UnexpectednessScorer poolMember : pool ) {
		int resultsConsidered = 0;
		for (int succ : poolMember.results(node, howMany))
			if (consideredSuccessors.contains(succ)) {
				resultsConsidered++;
				unmatchedSuccessors.remove(succ);
			}
		
		if (resultsConsidered == 0)
			LOGGER.warn(
					poolMember.toString()
					+ " got no considered results for query " + id2name.get(node)
					);
		
		double fractionOfItsResultsOverConsideredResults =
				(double) resultsConsidered / consideredSuccessors.size();
		retriever2itsFraction.get(poolMember).addValue(fractionOfItsResultsOverConsideredResults);
		retriever2evaluatedTopResults.get(poolMember).addValue((double) resultsConsidered / howMany);
	}
	
	double unmatchedResultsOverConsideredResults =
			(double) unmatchedSuccessors.size() / consideredSuccessors.size();
	unmatchStats.addValue(unmatchedResultsOverConsideredResults);
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
@CommandLine(argNames={"graph", "milestones"})
public HittingDistanceMinimizer(ImmutableGraph graph, IntSet milestones) {
	this.graph = Transform.transpose(graph);
	this.milestones = milestones;
	minMilestoneDistance = new int[graph.numNodes()];
	IntArrays.fill(minMilestoneDistance, Integer.MAX_VALUE);
	closestMilestone = new int[graph.numNodes()];
	IntArrays.fill(closestMilestone, -1);
	milestoneQueue = new IntArrayPriorityQueue(milestones.toIntArray());
	runningVisitors = new ObjectOpenHashSet<Visitor>();
	pl  = new ProgressLogger(LOGGER, "milestones");
	pl.expectedUpdates = milestones.size();
	
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
public IntSet getTopExcluding(final int k, final String[] excludedStrings, PrintWriter plainOutput) {
	LOGGER.info("Computing top-"+k+" categories from those whose name"
			+ " don't contains (case-insensitevely) "
			+ "any of "+Arrays.toString(excludedStrings)+"...");
	
	IntSet okIds = new IntOpenHashSet(k);
	boolean isNameOk;
	String name;
	for (int category : positions) {
		isNameOk = true;
		name = names.get(category).toLowerCase();
		for (String excludedString : excludedStrings)
			if (name.indexOf(excludedString) != -1) {
				isNameOk = false;
				break;
			}
		if (isNameOk) {
			okIds.add(category);
			if (plainOutput != null)
				plainOutput.println(names.get(category));
			if (okIds.size() == k)
				break;
		}
	}

	LOGGER.info("Top-"+k+" categories computed.");
	return okIds;
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
public InPredicateEvaluator(InPredicate predicate, Dictionary dictionary) {
  IntSet dictIds = new IntOpenHashSet();
  final String[] inValues = predicate.getInRange();
  for (final String value : inValues) {
    final int index = dictionary.indexOf(value);
    if (index >= 0) {
      dictIds.add(index);
    }
  }
  matchingIds = new int[dictIds.size()];
  int i = 0;
  for (int dictId : dictIds) {
    matchingIds[i++] = dictId;
  }
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
private void initStatistics() {
  IntSet _values = new IntOpenHashSet();
  for (int v : getTrace()) {
    _values.add(v);
    if (v < lowValue) {
      lowValue = v;
    }
    if (v > highValue) {
      highValue = v;
    }
  }
  valueCount = _values.size();
}
 

import it.unimi.dsi.fastutil.ints.IntSet; //导入方法依赖的package包/类
@Override
public int countUnique() {
    IntSet ints = new IntOpenHashSet(data);
    return ints.size();
}