Java TIntIntHashMap.keys方法代码示例

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
public PartialOrder(DifferenceSets differenceSets) {
	TIntIntHashMap orderMap = new TIntIntHashMap();
	
	for (DifferenceSet differenceSet : differenceSets) {
		// increase the cover count for set columns
		long bitIndex = 0;
		while (bitIndex < differenceSet.getNumberOfColumns()) {
			long currentNextSetBit = differenceSet.nextSetBit(bitIndex);
			if (currentNextSetBit != -1) {
				bitIndex = currentNextSetBit + 1;
				orderMap.putIfAbsent((int) currentNextSetBit, 0);
				orderMap.increment((int) currentNextSetBit);
			} else {
				bitIndex = differenceSet.getNumberOfColumns();
			}
		}
	}
	
	for (Integer index : orderMap.keys()) {
		this.add(new CoverOrder(index, orderMap.get(index)));
	}
	
	Collections.sort(this, Collections.reverseOrder());

}
 

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
private void dumpPathStats(TObjectIntHashMap<String> pathCounts,
		TIntIntHashMap pathlengthCounts) throws IOException {
	
	BufferedWriter writer = new BufferedWriter(new FileWriter("path.info"));
	for (int length : pathlengthCounts.keys()) {
		writer.write(""+length);
		writer.write("\t");
		writer.write(""+pathlengthCounts.get(length));
		writer.write("\n");
	}
	for (Object obj : pathCounts.keys()) {
		String key = (String) obj;
		writer.write(key);
		writer.write("\t");
		writer.write(""+pathCounts.get(key));
		writer.write("\n");
	}
	writer.close();
}
 

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
private void recacheStateTopicDistribution(int state, TIntIntHashMap topicCounts) {
int[] currentStateTopicCounts = stateTopicCounts[state];
double[][] currentStateCache = topicLogGammaCache[state];
double[] cache;

for (int topic: topicCounts.keys()) {
    cache = currentStateCache[topic];
    
    cache[0] = 0.0;
    for (int i=1; i < cache.length; i++) {
                   cache[i] =
                       cache[ i-1 ] +
                       Math.log( alpha[topic] + i - 1 + 
			  currentStateTopicCounts[topic] );
    }

}

docLogGammaCache[state][0] = 0.0;
for (int i=1; i < docLogGammaCache[state].length; i++) {
               docLogGammaCache[state][i] =
                   docLogGammaCache[state][ i-1 ] +
                   Math.log( alphaSum + i - 1 + 
		      stateTopicTotals[state] );
}
   }
 

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
public Instance pipe(Instance instance) {
	
	TIntIntHashMap localCounter = new TIntIntHashMap();

	if (instance.getData() instanceof FeatureSequence) {
			
		FeatureSequence features = (FeatureSequence) instance.getData();

		for (int position = 0; position < features.size(); position++) {
			localCounter.adjustOrPutValue(features.getIndexAtPosition(position), 1, 1);
		}

	}
	else {
		throw new IllegalArgumentException("Looking for a FeatureSequence, found a " + 
										   instance.getData().getClass());
	}

	for (int feature: localCounter.keys()) {
		counter.increment(feature);
	}

	numInstances++;

	return instance;
}
 

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
private double norm(TIntIntHashMap map) {

        int sum = 0;
        for (int i : map.keys()) {
            sum += (Math.pow(map.get(i), 2));
        }

        return Math.sqrt(sum);
    }
 

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
@Override
public String toString() {
	final String nl = System.getProperty("line.separator");
	final StringBuilder sb = new StringBuilder();

	for (final Entry<String, TIntIntHashMap> e : countResults.entrySet()) {

		// add the id of the timeseries
		sb.append(e.getKey());
		sb.append(": ");

		// add each label
		final TIntIntHashMap vals = e.getValue();
		final int[] keys = vals.keys();
		Arrays.sort(keys);
		for (int i = 0; i < keys.length; i++) {
			if (i > 0) {
				sb.append("; ");
			}

			sb.append(String.format(Locale.US, "%d (%d)",
					vals.get(keys[i]), i));
		}
		sb.append(nl);
	}

	return sb.toString().trim();
}
 

import gnu.trove.map.hash.TIntIntHashMap; //导入方法依赖的package包/类
public MultinomialHMM (int numberOfTopics, String topicsFilename, int numStates) throws IOException {
formatter = NumberFormat.getInstance();
formatter.setMaximumFractionDigits(5);

System.out.println("LDA HMM: " + numberOfTopics);

documentTopics = new TIntObjectHashMap<TIntIntHashMap>();

this.numTopics = numberOfTopics;
this.alphaSum = numberOfTopics;
this.alpha = new double[numberOfTopics];
Arrays.fill(alpha, alphaSum / numTopics);

topicKeys = new String[numTopics];

// This initializes numDocs as well
loadTopicsFromFile(topicsFilename);

documentStates = new int[ numDocs ];
documentSequenceIDs = new int[ numDocs ];

maxTokensPerTopic = new int[ numTopics ];
maxDocLength = 0;

//int[] histogram = new int[380];
//int totalTokens = 0;

for (int doc=0; doc < numDocs; doc++) {
    if (! documentTopics.containsKey(doc)) { continue; }
    
    TIntIntHashMap topicCounts = documentTopics.get(doc);
    
    int count = 0;
    for (int topic: topicCounts.keys()) {
	int topicCount = topicCounts.get(topic);
	//histogram[topicCount]++;
	//totalTokens += topicCount;

	if (topicCount > maxTokensPerTopic[topic]) {
	    maxTokensPerTopic[topic] = topicCount;
	}
	count += topicCount;
    }
    if (count > maxDocLength) {
	maxDocLength = count;
    }
}

/*
double runningTotal = 0.0;
for (int i=337; i >= 0; i--) {
    runningTotal += i * histogram[i];
    System.out.format("%d\t%d\t%.3f\n", i, histogram[i], 
		      runningTotal / totalTokens);
}
*/

this.numStates = numStates; 
this.initialStateCounts = new int[numStates];

topicLogGammaCache = new double[numStates][numTopics][];
for (int state=0; state < numStates; state++) {
    for (int topic=0; topic < numTopics; topic++) {
	topicLogGammaCache[state][topic] = new double[ maxTokensPerTopic[topic] + 1 ];
	//topicLogGammaCache[state][topic] = new double[21];

    }
}
System.out.println( maxDocLength );
docLogGammaCache = new double[numStates][ maxDocLength + 1 ];

   }