import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
public boolean isUniqueWith(int[][] compressedRecords, OpenBitSet otherAttrs, List<IntegerPair> comparisonSuggestions) {
	int attrsSize = (int) otherAttrs.cardinality();
	
	for (IntArrayList cluster : this.clusters) {
		Object2IntOpenHashMap<ClusterIdentifier> value2record = new Object2IntOpenHashMap<>(cluster.size());
		for (int recordId : cluster) {
			ClusterIdentifier value = this.buildClusterIdentifier(otherAttrs, attrsSize, compressedRecords[recordId]);
			if (value == null)
				continue;
			if (value2record.containsKey(value)) {
				comparisonSuggestions.add(new IntegerPair(recordId, value2record.getInt(value)));
				return false;
			}
			value2record.put(value, recordId);
		}
	}
	return true;
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
public boolean refines(int[][] lhsInvertedPlis, int[] rhs) {
	for (IntArrayList cluster : this.clusters) {
		Object2IntOpenHashMap<IntArrayList> clustersMap = new Object2IntOpenHashMap<>(cluster.size());
		
		// Check if all subclusters of this cluster point into the same other clusters
		for (int recordId : cluster) {
			IntArrayList additionalLhsCluster = this.buildClusterIdentifier(recordId, lhsInvertedPlis);
			if (additionalLhsCluster == null)
				continue;
			
			if (clustersMap.containsKey(additionalLhsCluster)) {
				if ((rhs[recordId] == -1) || (clustersMap.getInt(additionalLhsCluster) != rhs[recordId]))
					return false;
			}
			else {
				clustersMap.put(additionalLhsCluster, rhs[recordId]);
			}
		}
	}
	return true;
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * @deprecated use {@link #readEntityIdsMapping(JavaRDD)} instead, to get the entity mappings used in blocking
 * Maps an entity url to its entity id, that is also used by blocking.
 * @param rawTriples
 * @param SEPARATOR
 * @return a map from an entity url to its entity id, that is also used by blocking.
 */
public static Object2IntOpenHashMap<String> getEntityIdsMapping(JavaRDD<String> rawTriples, String SEPARATOR) {        
    LinkedHashSet<String> subjectsSet =                  
        new LinkedHashSet<>(rawTriples
        .map(line -> line.split(SEPARATOR)[0])
        .collect()                
        ); //convert list to set (to remove duplicates)
    
    Object2IntOpenHashMap<String> result = new Object2IntOpenHashMap<>(subjectsSet.size());
    result.defaultReturnValue(-1);
    int index = 0;
    for (String subject : subjectsSet) {
        result.put(subject, index++);
    }
    return result;
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Return the ground truth in an RDD format, each entity represented with an integer entity id. 
 * @param entityIds1RDD
 * @param entityIds2RDD
 * @param gt
 * @param GT_SEPARATOR
 * @return 
 */
public static JavaPairRDD<Integer,Integer> getGroundTruthIdsFromEntityIds (JavaRDD<String> entityIds1RDD, JavaRDD<String> entityIds2RDD, JavaRDD<String> gt, String GT_SEPARATOR) {
    Object2IntOpenHashMap<String> entityIds1 = readEntityIdsMapping(entityIds1RDD, true);
    Object2IntOpenHashMap<String> entityIds2 = readEntityIdsMapping(entityIds2RDD, false); 
    
    return gt.mapToPair(line -> {
                line = line.toLowerCase();
                String [] parts = line.split(GT_SEPARATOR);                    
                parts[1] = encodeURIinUTF8(parts[1]);
                return new Tuple2<>(-entityIds2.getOrDefault(parts[1], -1), //negative id first (keep default -1, since -(-1) == 1)
                                    entityIds1.getOrDefault(parts[0], -1)); //positive id second
            })
            .filter(x-> x._1() != 1 && x._2() != -1) //throw away pairs whose elements (one or both) do not appear in the dataset
            //remove pairs violating the clean-clean constraint
            .aggregateByKey(new IntOpenHashSet(), 
                    (x,y) -> {x.add(y); return x;}, 
                    (x,y) -> {x.addAll(y); return x;})
            .filter(x -> x._2().size() == 1) //not more than one match allowed per (negative) entity
            .mapValues(x -> x.iterator().next());
            
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Return an RDD with keys: label objects, and values: entity ids from a single collection, having this label
 * @param inputTriples
 * @param labelAtts
 * @param entityIds
 * @param SEPARATOR
 * @param positiveIds
 * @return 
 */
private JavaPairRDD<String,Integer> getLabelBlocks(JavaRDD<String> inputTriples, Set<String> labelAtts, JavaRDD<String> entityIds, String SEPARATOR, boolean positiveIds) {
    Object2IntOpenHashMap<String> urls1 = Utils.readEntityIdsMapping(entityIds, positiveIds);
    return inputTriples.mapToPair(line -> {
    String[] spo = line.toLowerCase().replaceAll(" \\.$", "").split(SEPARATOR); //lose the ending " ." from valid .nt files
      if (spo.length < 3) {
          return null;
      }          
      if (labelAtts.contains(spo[1])) {
        String labelValue = line.substring(line.indexOf(spo[1])+spo[1].length()+SEPARATOR.length())
                .toLowerCase().replaceAll("[^a-z0-9 ]", "").trim();
        int subjectId = urls1.getInt(Utils.encodeURIinUTF8(spo[0])); //replace subject url with entity id
        if (!positiveIds) {
            subjectId = -subjectId;
        }
        return new Tuple2<String,Integer>(labelValue,subjectId);
      } else {
          return null;
      }          
    })
    .filter(x-> x!= null)
    .distinct();
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Creates a new sample list from a existing collection of elements.
 *
 * <p>
 *     Elements will be indexed as they appear in the input array. Repeats will be ignored.
 * </p>
 *
 * @param values the original sample list.
 *
 * @throws IllegalArgumentException
 * if {@code values} array is {@code null} itself, or it contains {@code null}.
 */
@SuppressWarnings("unchecked")
public IndexedSet(final Collection<E> values) {
    if (values == null)
        throw new IllegalArgumentException("input values cannot be null");

    final int initialCapacity = values.size();
    elements = new ArrayList<>(initialCapacity);
    indexByElement = new Object2IntOpenHashMap<>(initialCapacity);
    int nextIndex = 0;
    for (final E value : values) {
        if (value == null)
            throw new IllegalArgumentException("null element not allowed: index == " + nextIndex);
        if (indexByElement.containsKey(value))
            continue;
        indexByElement.put(value, nextIndex++);
        elements.add(value);
    }
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Computes the score of a given type using the log-likelihood with respect to a previously computed language model
 *
 * @param type identifier of the type you are scoring
 * @return score of the type for the previously set context
 */
public double getScoreOf( short type ) {
    Double score = scoreCache.get( type );
    if( score != null ) return score;
    score = 0D;
    final String t = typeMapping.get( type );
    if( t == null ) return DEFAULT_SCORE; //type not found in mapping - warning?
    final Object2IntOpenHashMap<String> lm = models.languageModels.get( t );
    if( lm == null ) return DEFAULT_SCORE;
    for( String w : ngrams ) {
        Integer f = lm.get( w );
        if( f != null ) { //else add zero, = do nothing
            score += Math.log( ( f + muLM * ( ( double ) models.backgroundModel.get( w ) / models.totalFreq ) ) / ( models.freqs.get( t ) + muLM ) );
        }
    }
    if( score == 0D ) score = DEFAULT_SCORE;
    scoreCache.put( type, score );
    return score;
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
public Object2IntMap<String> calculateDocVec(List<String> tokens) {

		Object2IntMap<String> docVec = new Object2IntOpenHashMap<String>();
		// add the word-based vector
		if(this.createWordAtts)
			docVec.putAll(affective.core.Utils.calculateTermFreq(tokens,UNIPREFIX,this.freqWeights));

		if(this.createClustAtts){
			// calcultates the vector of clusters
			List<String> brownClust=affective.core.Utils.clustList(tokens,brownDict);
			docVec.putAll(affective.core.Utils.calculateTermFreq(brownClust,CLUSTPREFIX,this.freqWeights));			
		}	


		return docVec;

	}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
public Object2IntMap<String> calculateDocVec(List<String> tokens) {

		Object2IntMap<String> docVec = new Object2IntOpenHashMap<String>();
		// add the word-based vector
		if(this.createWordAtts)
			docVec.putAll(affective.core.Utils.calculateTermFreq(tokens,UNIPREFIX,this.freqWeights));

		if(this.createClustAtts){
			// calcultates the vector of clusters
			List<String> brownClust=affective.core.Utils.clustList(tokens,brownDict);
			docVec.putAll(affective.core.Utils.calculateTermFreq(brownClust,CLUSTPREFIX,this.freqWeights));			
		}	

		return docVec;

	}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Calculates a vector of attributes from a list of tokens
 * 
 * @param tokens the input tokens 
 * @param prefix the prefix of each vector attribute
 * @return an Object2IntMap object mapping the attributes to their values
 */		
public static Object2IntMap<String> calculateTermFreq(List<String> tokens, String prefix, boolean freqWeights) {
	Object2IntMap<String> termFreq = new Object2IntOpenHashMap<String>();

	// Traverse the strings and increments the counter when the token was
	// already seen before
	for (String token : tokens) {
		// add frequency weights if the flat is set
		if(freqWeights)
			termFreq.put(prefix+token, termFreq.getInt(prefix+token) + 1);
		// otherwise, just consider boolean weights
		else{
			if(!termFreq.containsKey(token))
				termFreq.put(prefix+token, 1);
		}
	}

	return termFreq;
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
private void initiateFromArrayWithMap(InterdependentProblemPart<?, ?>[] allParts, 
		Object2IntOpenHashMap<UUID> uuidIntMap) {
	keyMap = new Object2IntOpenHashMap<UUID>(allParts.length);
	partIdToArrayIdMap = new int[uuidIntMap.size()];
	innerValues = new LimitedCommodityStateMap[allParts.length];
	
	keyMap.defaultReturnValue(-1);
	Arrays.fill(partIdToArrayIdMap, -1);
	
	for (int i = 0; i < allParts.length; i++) {
		if (uuidIntMap.containsKey(allParts[i].getDeviceID())) {
			keyMap.put(allParts[i].getDeviceID(), i);
			partIdToArrayIdMap[allParts[i].getId()] = i;
			innerValues[i] = new LimitedCommodityStateMap();
		} else {
			throw new IllegalArgumentException("no mapping for specified key");
		}
	}
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
public UUIDCommodityMap(InterdependentProblemPart<?, ?>[] allParts, 
		Object2IntOpenHashMap<UUID> uuidIntMap,
		boolean makeNoMap) {
	
	if (!makeNoMap) {
		initiateFromArrayWithMap(allParts, uuidIntMap);
	}
	keyMap = null;
	partIdToArrayIdMap = new int[uuidIntMap.size()];
	innerValues = new LimitedCommodityStateMap[allParts.length];
	
	Arrays.fill(partIdToArrayIdMap, -1);
	
	for (int i = 0; i < allParts.length; i++) {
		if (uuidIntMap.containsKey(allParts[i].getDeviceID())) {
			partIdToArrayIdMap[allParts[i].getId()] = i;
			innerValues[i] = new LimitedCommodityStateMap();
		} else {
			throw new IllegalArgumentException("no mapping for specified key");
		}
	}
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Returns a score for the recommendation list.
 *
 * @param recommendation recommendation list
 * @return score of the metric to the recommendation
 */
@Override
public double evaluate(Recommendation<U, I> recommendation) {
    RelevanceModel.UserRelevanceModel<U, I> userRelModel = relModel.getModel(recommendation.getUser());
    BinomialModel<U, I, F>.UserBinomialModel prob = binomialModel.getModel(recommendation.getUser());

    Object2IntOpenHashMap<F> count = new Object2IntOpenHashMap<>();
    count.defaultReturnValue(0);

    int rank = 0;
    int nrel = 0;
    for (Tuple2od<I> iv : recommendation.getItems()) {
        if (userRelModel.isRelevant(iv.v1)) {
            featureData.getItemFeatures(iv.v1)
                    .forEach(fv -> count.addTo(fv.v1, 1));
            nrel++;
        }

        rank++;
        if (rank >= cutoff) {
            break;
        }
    }

    return getResultFromCount(prob, count, nrel, rank);
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param recommendation input recommendation to be re-ranked
 * @param maxLength number of items to be greedily selected
 */
public BinomialNonRedundancyUserReranker(Recommendation<U, I> recommendation, int maxLength) {
    super(recommendation, maxLength);

    ubm = binomialModel.getModel(recommendation.getUser());

    featureCount = new Object2IntOpenHashMap<>();
    featureCount.defaultReturnValue(0);

    patienceNow = new Object2DoubleOpenHashMap<>();
    patienceLater = new Object2DoubleOpenHashMap<>();
    ubm.getFeatures().forEach(f -> {
        patienceNow.put(f, ubm.patience(0, f, cutoff));
        patienceLater.put(f, ubm.patience(1, f, cutoff));
    });
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 *
 * @param referenceWindowSize size of the maximum size of the list index between current list and its encoded value
 *                            list index.
 * @param outputBitStream output stream where a new encoded element will be written.
 * @param offsetsStore stores the current offset after each element is written.
 * @param encodingInfo encodingInfo used to keep track of relevant encoding information.
 */
@SuppressWarnings({"unchecked"})
public TypeMapEncoder(
    final int referenceWindowSize,
    final OutputBitStream outputBitStream,
    final PebbleOffsetsStoreWriter offsetsStore,
    final EncodingInfo encodingInfo
) {
    this.referenceWindowSize = referenceWindowSize;
    this.outputBitStream = outputBitStream;
    this.offsetsStore = offsetsStore;
    this.encodingInfo = encodingInfo;
    this.buffer = (T[]) new Object[referenceWindowSize];
    this.bufferIndex = 0;
    this.map = new Object2IntOpenHashMap<T>();
    this.map.defaultReturnValue(MISSING_MAP_VALUE);
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
@Override
public ClassLabel classify(O instance) {
  Object2IntOpenHashMap<ClassLabel> count = new Object2IntOpenHashMap<>();
  KNNList query = knnq.getKNNForObject(instance, k);
  for(DoubleDBIDListIter neighbor = query.iter(); neighbor.valid(); neighbor.advance()) {
    count.addTo(labelrep.get(neighbor), 1);
  }

  int bestoccur = Integer.MIN_VALUE;
  ClassLabel bestl = null;
  for(ObjectIterator<Entry<ClassLabel>> iter = count.object2IntEntrySet().fastIterator(); iter.hasNext();) {
    Entry<ClassLabel> entry = iter.next();
    if(entry.getIntValue() > bestoccur) {
      bestoccur = entry.getIntValue();
      bestl = entry.getKey();
    }
  }
  return bestl;
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * Rearrange the targets so that they are in a particular order.
 * @return a new collection.
 * @throws IllegalArgumentException if any of the following is true:
 * <ul>
 *     <li>{@code targetsInOrder} is {@code null},</li>
 *     <li>is empty,</li>
 *     <li>it contains {@code null},</li>
 *     <li>contains any target not present in this collection.</li>
 * </ul>
 */
public ReadCountCollection arrangeTargets(final List<Target> targetsInOrder) {
    Utils.nonNull(targetsInOrder);
    Utils.nonEmpty(targetsInOrder, "the input targets list cannot be empty");
    final RealMatrix counts = new Array2DRowRealMatrix(targetsInOrder.size(), columnNames.size());
    final Object2IntMap<Target> targetToIndex = new Object2IntOpenHashMap<>(targets.size());
    for (int i = 0; i < targets.size(); i++) {
        targetToIndex.put(targets.get(i), i);
    }
    for (int i = 0; i < targetsInOrder.size(); i++) {
        final Target target = targetsInOrder.get(i);
        Utils.validateArg(targetToIndex.containsKey(target), () -> String.format("target '%s' is not present in the collection", target.getName()));
        counts.setRow(i, this.counts.getRow(targetToIndex.getInt(target)));
    }
    return new ReadCountCollection(new ArrayList<>(targetsInOrder), columnNames, counts, false);
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
/**
 * List of lines are generated from a given file. then this list is used to generate a NodeNamerImpl
 *
 * @param file
 * @return INodeNamer
 * @throws IOException
 */
public static INodeNamer load(final File file) throws IOException {
    final int numNodes = countLines(file, Encoding.DEFAULT_CHARSET_NAME);

    final Int2ObjectOpenHashMap<String> id2Label = new Int2ObjectOpenHashMap<String>(numNodes);
    final Object2IntOpenHashMap<String> label2Id = new Object2IntOpenHashMap<String>(numNodes);

    final LineIterator it = FileUtils.lineIterator(file, Encoding.DEFAULT_CHARSET_NAME);
    try {
        int curId = 0;
        while(it.hasNext()) {
            final String nodeName = it.next();
            id2Label.put(curId, nodeName);
            label2Id.put(nodeName, curId);
            curId++;
        }

        return new NodeNamerImpl(id2Label, label2Id);
    } finally {
        it.close();
    }
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
@Override
public void close() {
  synchronized(LuceneLinkTokenizer.this) {
    Object2IntOpenHashMap<String> plinks = LuceneLinkTokenizer.this.links;
    if(plinks.size() == 0) {
      LuceneLinkTokenizer.this.links = links;
    }
    else {
      for(ObjectIterator<Object2IntOpenHashMap.Entry<String>> it = links.object2IntEntrySet().fastIterator(); it.hasNext();) {
        Object2IntOpenHashMap.Entry<String> ent = it.next();
        plinks.addTo(ent.getKey(), ent.getIntValue());
      }
    }
    links = null;
  }
}
 

import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; //导入依赖的package包/类
public static void run( final FastBufferedReader fbr, final DataOutputStream dos, ProgressLogger pl ) throws IOException {
	final MutableString s = new MutableString();
	Object2IntOpenHashMap<MutableString> map = new Object2IntOpenHashMap<MutableString>();
	map.defaultReturnValue( -1 );
	int slash, hostIndex = -1;

	if ( pl != null ) pl.start( "Reading URLS..." );
	while( fbr.readLine( s ) != null ) {
		slash = s.indexOf( '/', 8 );
		// Fix for non-BURL URLs
		if ( slash != -1 ) s.length( slash );
		if ( ( hostIndex = map.getInt( s ) ) == -1 ) map.put( s.copy(), hostIndex = map.size() );
		dos.writeInt( hostIndex );
		if ( pl != null ) pl.lightUpdate();
	}
	
	if ( pl != null ) pl.done();
}