Java ObjectIntMap类代码示例

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
static void assignLabels(AnnotationProvider annotationProvider,
                         List<DefaultDomain> domains) {

    domains.stream()
           .forEach(domain -> {
               ObjectIntMap<String> wordCounts = new ObjectIntHashMap<>();

               domain.forEachAttribute(attributeIndex -> {
                   String label = annotationProvider.getAttributeLabel(attributeIndex);
                   if (label == null) {
                       return;
                   }

                   countWords(wordCounts, label);
               });

               List<String> topWords = computeTopWords(wordCounts);
               domain.name = String.join(" ", topWords);
           });
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
static List<String> computeTopWords(ObjectIntMap<String> wordCounts) {
    return StreamSupport.stream(wordCounts.spliterator(), false)
                        .map(c -> new WordCount(c.key, c.value))
                        .sorted((w1,
                                 w2) -> {
                            // Sort by count (descending) first
                            int result = w2.count - w1.count;
                            if (result != 0) {
                                return result;
                            }

                            // ...then by label
                            return w1.word.compareToIgnoreCase(w2.word);
                        })
                        .map(w -> w.word)
                        .limit(5)
                        .collect(Collectors.toList());
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
/**
 * creates a mapping between concept pairs and indices used in the ILP
 * 
 * @param predictions
 */
private ObjectIntMap<CPair> initVarMap(ObjectDoubleMap<CPair> predictions) {
	ObjectIntMap<CPair> varMap = new ObjectIntHashMap<CPair>();
	int x = 0;
	for (ObjectCursor<CPair> p : predictions.keys()) {
		varMap.put(p.value, x);
		x++;
	}
	return varMap;
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
static void countWords(ObjectIntMap<String> wordCounts,
                       String label) {
    String[] words = label.split(" ");
    Arrays.stream(words)
          .filter(word -> !isStopWord(word))
          .distinct()
          .forEach(word -> {
              int count = wordCounts.getOrDefault(word, 0);
              wordCounts.put(word, count + 1);
          });
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
@SuppressWarnings("PMD.DataflowAnomalyAnalysis")
public void check() {
	int color = DEFAULT_COLOR;
	ObjectIntMap<AbstractStage> colors = new ObjectIntHashMap<AbstractStage>();
	ThreadPainter threadPainter = new ThreadPainter();
	Traverser traverser = new Traverser(threadPainter);

	for (AbstractStage threadableStage : threadableStages) {
		color++;
		colors.put(threadableStage, color);

		threadPainter.reset(colors, color, threadableStages);
		traverser.traverse(threadableStage);
	}
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
private ObjectIntMap<String> generateFeatureMap(SourceOfRandomness sourceOfRandomness) {
    ObjectIntMap<String> featureMap = new ObjectIntHashMap<>();
    int numFeatures = sourceOfRandomness.nextInt(1,15);
    for (int i = 0; i < numFeatures; i++) {
        int featureValue = sourceOfRandomness.nextInt(20);
        while (featureMap.containsKey(""+featureValue)) {
            featureValue = sourceOfRandomness.nextInt(20);
        }

        featureMap.put(""+featureValue, sourceOfRandomness.nextInt(2));
    }
    return featureMap;
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
@Override
public ConcatVectorNamespace generate(SourceOfRandomness sourceOfRandomness, GenerationStatus generationStatus) {
    ConcatVectorNamespace namespace = new ConcatVectorNamespace();
    namespace.featureToIndex.putAll(generateFeatureMap(sourceOfRandomness));
    for (ObjectCursor<String> key : namespace.featureToIndex.keys()) {
        if (sourceOfRandomness.nextBoolean()) {
            ObjectIntMap<String> sparseMap = generateFeatureMap(sourceOfRandomness);
            IntObjectMap< String> reverseSparseMap = new IntObjectHashMap<>();
            for (ObjectCursor<String> sparseKey : sparseMap.keys()) reverseSparseMap.put(sparseMap.get(sparseKey.value), sparseKey.value);
            namespace.sparseFeatureIndex.put(key.value, sparseMap);
            namespace.reverseSparseFeatureIndex.put(key.value, reverseSparseMap);
        }
    }
    return namespace;
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
private List<Instruction> sortInstructions(Collection<Instruction> instructions, BasicBlock block) {
    ObjectIntMap<Instruction> indexes = new ObjectIntOpenHashMap<>();
    int index = 0;
    for (Instruction instruction : block) {
        indexes.put(instruction, index++);
    }
    List<Instruction> sortedInstructions = new ArrayList<>(instructions);
    sortedInstructions.sort(Comparator.comparing(insn -> indexes.getOrDefault(insn, -1)));
    return sortedInstructions;
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
private void putLiveInGCRoots(Program program, List<Map<Instruction, int[]>> updateInformation) {
    for (int i = 0; i < program.basicBlockCount(); ++i) {
        BasicBlock block = program.basicBlockAt(i);
        Map<Instruction, int[]> updatesByIndex = updateInformation.get(i);
        Instruction[] callSiteLocations = updatesByIndex.keySet().toArray(new Instruction[0]);
        ObjectIntMap<Instruction> instructionIndexes = getInstructionIndexes(block);
        Arrays.sort(callSiteLocations, Comparator.comparing(instructionIndexes::get));
        for (Instruction callSiteLocation : updatesByIndex.keySet()) {
            int[] updates = updatesByIndex.get(callSiteLocation);
            storeLiveIns(block, callSiteLocation, updates);
        }
    }
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
private ObjectIntMap<Instruction> getInstructionIndexes(BasicBlock block) {
    ObjectIntMap<Instruction> indexes = new ObjectIntOpenHashMap<>();
    for (Instruction instruction : block) {
        indexes.put(instruction, indexes.size());
    }
    return indexes;
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
public void reset(final ObjectIntMap<AbstractStage> colors, final int color, final Set<AbstractStage> threadableStages) {
	this.colors = colors;
	this.color = color;
	this.threadableStages = threadableStages;
}
 

import com.carrotsearch.hppc.ObjectIntMap; //导入依赖的package包/类
public TransducerAlphabet(DataInputStream charstream, int number_of_symbols) throws java.io.IOException {
	keyTable = new ArrayList<String>();
	operations = new IntObjectHashMap<FlagDiacriticOperation>();
	ObjectIntMap<String> feature_bucket = new ObjectIntHashMap<String>();
	ObjectIntMap<String> value_bucket = new ObjectIntHashMap<String>();
	features = 0;
	int values = 1;
	value_bucket.put("", 0); // neutral value
	int i = 0;
	int charindex;
	ByteArrayList chars = new ByteArrayList();
	while (i < number_of_symbols) {
		charindex = 0;
		if (chars.size()==charindex)
			chars.add(charstream.readByte());
		else chars.set(charindex,charstream.readByte());
		while (chars.get(charindex) != 0) {
			++charindex;
			if (chars.size()==charindex)
				chars.add(charstream.readByte());
			else chars.set(charindex,charstream.readByte());
		}
		String ustring = new String(chars.toArray(), 0, charindex, "UTF-8");
		if (ustring.length() > 5 && ustring.charAt(0) == '@' && ustring.charAt(ustring.length() - 1) == '@' && ustring.charAt(2) == '.') { // flag diacritic identified
			HfstOptimizedLookup.FlagDiacriticOperator op;
			String[] parts = ustring.substring(1, ustring.length() - 1).split("\\.");
			/* Not a flag diacritic after all, ignore it */
			if (parts.length < 2) {
				keyTable.add("");
				i++;
				continue;
			}
			String ops = parts[0];
			String feats = parts[1];
			String vals;
			if (parts.length == 3)
				vals = parts[2];
			else vals = "";
			if (ops.equals("P"))
				op = HfstOptimizedLookup.FlagDiacriticOperator.P;
			else if (ops.equals("N"))
				op = HfstOptimizedLookup.FlagDiacriticOperator.N;
			else if (ops.equals("R"))
				op = HfstOptimizedLookup.FlagDiacriticOperator.R;
			else if (ops.equals("D"))
				op = HfstOptimizedLookup.FlagDiacriticOperator.D;
			else if (ops.equals("C"))
				op = HfstOptimizedLookup.FlagDiacriticOperator.C;
			else if (ops.equals("U"))
				op = HfstOptimizedLookup.FlagDiacriticOperator.U;
			else { // Not a valid operator, ignore the operation
				keyTable.add("");
				i++;
				continue;
			}
			if (value_bucket.containsKey(vals) == false) {
				value_bucket.put(vals, values);
				values++;
			}
			if (feature_bucket.containsKey(feats) == false) {
				feature_bucket.put(feats, features);
				features++;
			}
			operations.put(i, new FlagDiacriticOperation(op, feature_bucket.get(feats), value_bucket.get(vals)));
			keyTable.add("");
			i++;
			continue;
		}
		keyTable.add(ustring);
		i++;
	}
	keyTable.set(0, ""); // epsilon is zero
}