import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public double compute(TIntDoubleHashMap doc1, TIntDoubleHashMap doc2, IIntIterator features) {

        double numerator = 0;
        double denominator1 = 0;
        double denominator2 = 0;

        features.begin();
        while (features.hasNext()) {
            int featID = features.next();

            double doc1s = doc1.get(featID);
            double doc2s = doc2.get(featID);

            numerator += (doc1s * doc2s);
            denominator1 += (doc1s * doc1s);
            denominator2 += (doc2s * doc2s);
        }

        double denominator = Math.sqrt(denominator1) * Math.sqrt(denominator2);

        double similarity = numerator / denominator;
        if (similarity > 1)
            similarity = 1;

        return similarity;
    }
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public double compute(int doc1, int doc2, IIndex index) {

        TIntDoubleHashMap ar1 = new TIntDoubleHashMap(index.getFeatureDB()
                .getFeaturesCount());
        TIntDoubleHashMap ar2 = new TIntDoubleHashMap(index.getFeatureDB()
                .getFeaturesCount());

        IIntIterator features = index.getFeatureDB().getFeatures();
        while (features.hasNext()) {
            int featID = features.next();

            ar1.put(featID,
                    index.getWeightingDB().getDocumentFeatureWeight(doc1,
                            featID));
            ar2.put(featID,
                    index.getWeightingDB().getDocumentFeatureWeight(doc2,
                            featID));
        }

        features.begin();
        return compute(ar1, ar2, features);
    }
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public TIntArrayList get(TIntDoubleHashMap table) {
    final ArrayList<ComparablePair> list = new ArrayList<ComparablePair>(
            table.size());
    class Procedure implements TIntDoubleProcedure {
        @Override
        public boolean execute(int a, double b) {
            list.add(new ComparablePair(a, b));
            return true;
        }
    }
    table.forEachEntry(new Procedure());
    Collections.sort(list);
    TIntArrayList result = new TIntArrayList(list.size());
    for (int i = 0; i < list.size(); i++) {
        result.add(list.get(i).getFirst());
    }
    return result;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public Incremental(int trainSize, ClassificationScoreDB classification, TIntHashSet categoriesFilter,
                   EstimationType estimation, ContingencyTableSet evaluation, IGain gain, IGain firstRankGain, double[] probabilitySlope, double[] prevalencies) {
    super(trainSize, classification, categoriesFilter, estimation, evaluation, firstRankGain, probabilitySlope, prevalencies);
    macroRankTable = new TIntDoubleHashMap((int) (testSize + testSize * 0.25), (float) 0.75);
    microRankTable = new TIntDoubleHashMap((int) (testSize + testSize * 0.25), (float) 0.75);
    macroAlreadySeen = new TIntHashSet((int) (testSize + testSize * 0.25), (float) 0.75);
    microAlreadySeen = new TIntHashSet((int) (testSize + testSize * 0.25), (float) 0.75);
    probabilities = new double[testSize][numOfCategories];
    for (int docId = 0; docId < testSize; docId++) {
        Set<Entry<Short, ClassifierRangeWithScore>> entries = classification.getDocumentScoresAsSet(docId);
        Iterator<Entry<Short, ClassifierRangeWithScore>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Entry<Short, ClassifierRangeWithScore> next = iterator.next();
            ClassifierRangeWithScore value = next.getValue();
            if (categoriesFilter.contains(next.getKey())) {
                probabilities[docId][catMap.get(next.getKey())] = probability(Math.abs(value.score - value.border), next.getKey());
            }
        }
    }
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public TIntDoubleHashMap getTable() {
    TIntDoubleHashMap rank = new TIntDoubleHashMap((int) (testSize + testSize * 0.25), (float) 0.75);
    for (int docId = 0; docId < testSize; docId++) {
        Set<Entry<Short, ClassifierRangeWithScore>> entries = classification.getDocumentScoresAsSet(docId);
        Iterator<Entry<Short, ClassifierRangeWithScore>> iterator = entries.iterator();
        double sum = 0.0;
        while (iterator.hasNext()) {
            Entry<Short, ClassifierRangeWithScore> next = iterator.next();
            if (categoriesFilter.contains(next.getKey()) && docCategoriesFilter[docId].contains(next.getKey())) {
                ClassifierRangeWithScore value = next.getValue();
                sum += probability(Math.abs(value.score - value.border), next.getKey());
                //System.out.println(docId + " " + next.getKey() + " " + probability(Math.abs(value.score - value.border), next.getKey()));
                //System.out.println(next.getKey() + " " + slopes[next.getKey()] + " " + value.score);
            }
        }
        rank.put(docId, sum);
    }
    return rank;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public void addEdge(int i, int j, double weight) {
	ExceptionUtility.verifyIndex(this.numVertices, i);
	ExceptionUtility.verifyIndex(this.numVertices, j);
	int x = (i < j ? i : j);
	int y = (i < j ? j : i);
	if (!this.adjacencySets.containsKey(y)) {
		this.adjacencySets.put(y, new TIntDoubleHashMap());
	}
	this.adjacencySets.get(y).put(x, weight);
	
	if (!this.degrees.containsKey(x)) {
		this.degrees.put(x, 0);
	}
	if (!this.degrees.containsKey(y)) {
		this.degrees.put(y, 0);
	}
	this.degrees.put(x, this.degrees.get(x) + 1);
	this.degrees.put(y, this.degrees.get(y) + 1);
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public TroveWeightingDB(IContentDB contentDB) {
    super();
    _contentDB = contentDB;
    int size = contentDB.getDocumentDB().getDocumentsCount();
    _documentsWeights = new Vector<TIntDoubleHashMap>(size);
    for (int i = 0; i < size; ++i) {
        _documentsWeights.add(new TIntDoubleHashMap());
    }

    _name = "generic";
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public double getDocumentFeatureWeight(int document, int feature) {
    if (_contentDB.hasDocumentFeature(document, feature)) {
        if (document < _documentsWeights.size()) {
            TIntDoubleHashMap weights = _documentsWeights.get(document);
            if (weights.containsKey(feature))
                return weights.get(feature);
            else
                return 1.0;
        } else
            return 1.0;
    } else
        return 0.0;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public IWeightingDB cloneDB(IContentDB contentDB) {
    TroveWeightingDB weightingDB = new TroveWeightingDB(contentDB);
    weightingDB._name = new String(_name);

    weightingDB._documentsWeights = new Vector<TIntDoubleHashMap>(
            _documentsWeights.size());
    for (int i = 0; i < _documentsWeights.size(); ++i)
        weightingDB._documentsWeights
                .add((TIntDoubleHashMap) _documentsWeights.get(i).clone());

    return weightingDB;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public void setDocumentFeatureWeight(int document, int feature,
                                     double weight) {
    if (_weightingDB.getContentDB().hasDocumentFeature(document, feature)) {
        while (document >= _weightingDB._documentsWeights.size())
            _weightingDB._documentsWeights.add(new TIntDoubleHashMap());
        _weightingDB._documentsWeights.get(document).put(feature, weight);
    }
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public static TIntDoubleHashMap computeDocumentCentroid(IIntIterator docs,
                                                        IIndex index) {
    TIntDoubleHashMap centroid = new TIntDoubleHashMap(index.getFeatureDB()
            .getFeaturesCount());

    int numDoc = 0;
    docs.begin();
    while (docs.hasNext()) {
        int docID = docs.next();
        IIntIterator feats = index.getContentDB()
                .getDocumentFeatures(docID);
        while (feats.hasNext()) {
            int featID = feats.next();

            centroid.put(
                    featID,
                    centroid.get(featID)
                            + index.getWeightingDB()
                            .getDocumentFeatureWeight(docID, featID));
        }

        numDoc++;
    }

    int keys[] = centroid.keys();
    for (int i = 0; i < keys.length; i++) {
        centroid.put(keys[i], centroid.get(keys[i]) / (double) numDoc);
    }

    return centroid;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public double compute(TIntDoubleHashMap doc1, TIntDoubleHashMap doc2, IIntIterator features) {

        double l = 0;

        features.begin();
        while (features.hasNext()) {
            int featID = features.next();
            l += Math.pow(doc1.get(featID) - doc2.get(featID), 2);
        }

        l = Math.sqrt(l);

        return l;
    }
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public double compute(TIntDoubleHashMap doc1, TIntDoubleHashMap doc2, IIntIterator features) {

		double dist = 0;

		features.begin();
		while(features.hasNext()){
			int featID = features.next();
			dist += Math.pow(doc1.get(featID)-doc2.get(featID), 2);
		}

		return dist;
	}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
static public int getMax(TIntDoubleHashMap table) {
    int maxKey = -Integer.MIN_VALUE;
    double maxValue = Double.NEGATIVE_INFINITY;
    TIntDoubleIterator it = table.iterator();
    while (it.hasNext()) {
        it.advance();
        if (it.value() > maxValue) {
            maxValue = it.value();
            maxKey = it.key();
        }
    }
    return maxKey;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public TIntDoubleHashMap getTable(double[][] utilities) {
    TIntDoubleHashMap rank = new TIntDoubleHashMap(
            (int) (testSize + testSize * 0.25), (float) 0.75);
    for (int docId = 0; docId < testSize; docId++) {
        double sum = 0.0;
        for (TIntIterator it = categoriesFilter.iterator(); it.hasNext(); ) {
            int catId = it.next();
            if (docCategoriesFilter[docId].contains(catId)) {
                sum += utilities[docId][catMap.get(catId)];
            }
        }
        rank.put(docId, sum);
    }
    return rank;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
private TIntHashSet filterByTopProbabilities(int docId, int topK) {
    TIntDoubleHashMap topProbRank = new TIntDoubleHashMap((int) (testSize + testSize * 0.25), (float) 0.75);
    Set<Entry<Short, ClassifierRangeWithScore>> entries = classification.getDocumentScoresAsSet(docId);
    Iterator<Entry<Short, ClassifierRangeWithScore>> iterator = entries.iterator();
    while (iterator.hasNext()) {
        Entry<Short, ClassifierRangeWithScore> next = iterator.next();
        if (categoriesFilter.contains(next.getKey())) {
            ClassifierRangeWithScore value = next.getValue();
            topProbRank.put(next.getKey(), probability(Math.abs(value.score - value.border), next.getKey()));
        }
    }
    Ranker r = new Ranker();
    return new TIntHashSet(r.get(topProbRank).toNativeArray(0, topK));
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public TIntDoubleHashMap getTable() {
    TIntDoubleHashMap rank = new TIntDoubleHashMap(testSize);
    for (int i = 0; i < testSize; i++) {
        rank.put(i, Math.random());
    }
    return rank;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
@Override
public TIntDoubleHashMap getTable() {
    TIntDoubleHashMap rank = super.getTable();
    for (int docId = 0; docId < testSize; docId++) {
        if (rank.get(docId) != 0.0) {
            rank.adjustValue(docId, Math.random());
        }
    }
    return rank;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
public SparseVector(SparseVector other) {
	_dim_value = new TIntDoubleHashMap(other.size());
	int[] dims=other._dim_value.keys();
	for(int dim:dims)
		_dim_value.put(dim, other._dim_value.get(dim));
	_k = other._k;
}
 

import gnu.trove.TIntDoubleHashMap; //导入依赖的package包/类
protected TIntDoubleHashMap getDocumentAsMap(int docID, IIndex index) {
    TIntDoubleHashMap d2 = new TIntDoubleHashMap(index.getFeatureDB()
            .getFeaturesCount());
    IIntIterator features = index.getFeatureDB().getFeatures();
    while (features.hasNext()) {
        int featID = features.next();
        d2.put(featID,
                index.getWeightingDB().getDocumentFeatureWeight(docID,
                        featID));
    }

    return d2;
}