import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public void itemizeCandidates() {
	candidates = new THashSet<String>();
	IntCounter<String> counts = new IntCounter<String>();
	for (DataPointWithElements p : mData) {
		
		for (Range fillerSpanRange : p.getOvertFrameElementFillerSpans()) {
			String ss = getSufficientStatistics(p.getParses().getBestParse(), fillerSpanRange);
			counts.increment(ss);
		}
	}
	
	for (TObjectIntIterator<String> iter = counts.getIterator(); iter.hasNext();) {
		iter.advance();
		if (iter.value()>=mMinCount)
			candidates.add(iter.key());
	}
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * If {@code this} is an {@link IntCounterMap} of the form <code> { a => { b => c } } </code>,
 * returns a new {@link IntCounterMap} of the form <code> { b => { a => c } } </code>.
 */
public IntCounterMap<L,K> invert() {
	IntCounterMap<L,K> invertedMap = new IntCounterMap<L,K>();
	for (Map.Entry<K,IntCounter<L>> item : this.entrySet()) {
		K key1 = item.getKey();
		IntCounter<L> counter = item.getValue();
		for (TObjectIntIterator<L> iter = counter.getIterator();
				iter.hasNext();) {
			iter.advance();
			L key2 = iter.key();
			int value = iter.value();
			invertedMap.set(key2, key1, value);
		}
	}
	return invertedMap;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * @param valueThreshold
 * @return Set of keys whose corresponding value equals or exceeds the given threshold
 */
public Set<T> filteredKeys(int valueThreshold) {
	Set<T> result = new THashSet<T>();
	for (TObjectIntIterator<T> iter = getIterator();
			iter.hasNext();) {
		iter.advance();
		T key = iter.key();
		int value = getT(key);
		if (value >= valueThreshold) {
			result.add(key);
		}
	}
	if (containsKey(null) && getT(null) >= valueThreshold)
		result.add(null);
	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * @param valueThreshold
 * @return New IntCounter containing only entries whose value equals or exceeds the given threshold
 */
public IntCounter<T> filter(int valueThreshold) {
	IntCounter<T> result = new IntCounter<T>();
	for (TObjectIntIterator<T> iter = getIterator();
			iter.hasNext();) {
		iter.advance();
		T key = iter.key();
		int value = getT(key);
		if (value >= valueThreshold) {
			result.set(key, value);
		}
	}
	int nullValue = getT(null);
	if (containsKey(null) && nullValue >= valueThreshold)
		result.set(null, nullValue);
	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * This function computes the operation low_A(j) as described in the paper. Note that if
 * the chain is empty (for example the column contains only zeros), then this function
 * returns null.
 * 
 * @param <X> the underlying type of the basis elements in the chain
 * @param chain the chain
 * @param comparator the comparator to use
 * @return the lowest element in the chain
 */
public static <X> X low(IntSparseFormalSum<X> chain, Comparator<X> comparator) {

	X maxObject = null;

	if (chain == null) {
		//System.out.println("stop");
		return null;
	}

	for (TObjectIntIterator<X> iterator = chain.iterator(); iterator.hasNext(); ) {
		iterator.advance();
		if (maxObject == null || comparator.compare(iterator.key(), maxObject) > 0) {
			maxObject = iterator.key();
		}
	}

	return maxObject;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * This function performs matrix multiplication. The matrix is represented by a sparse set of sparse columns. In other
 * words, this function computes the linear combination of the columns in the specified map with coefficients given by the
 * vector v. In the matrix m, the keys represent the column labels, and the values are the columns at that particular index.
 * 
 * @param <X>
 * @param <Y>
 * @param m the matrix as a list of columns
 * @param v the vector
 * @param field the field over which to perform the computations
 * @return the matrix vector product
 */
public static <X, Y> IntSparseFormalSum<Y> multiply(Map<X, IntSparseFormalSum<Y>> m, IntSparseFormalSum<X> v, IntAbstractField field) {
	IntSparseFormalSum<Y> result = new IntSparseFormalSum<Y>();
	IntAlgebraicFreeModule<Y> YChainModule = new IntAlgebraicFreeModule<Y>(field);

	for (TObjectIntIterator<X> iterator = v.iterator(); iterator.hasNext(); ) {
		iterator.advance();

		int coefficient = iterator.value();
		X object = iterator.key();
		IntSparseFormalSum<Y> column = m.get(object);
		if (column != null) {
			YChainModule.accumulate(result, column, coefficient);
		}
	}

	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * This function computes the boundary of a given chain, by linear extension.
 * 
 * @param <X>
 * @param chain the chain to compute the boundary of
 * @param chainModule the module that performs the computations
 * @return the boundary of the given chain
 */
public static <X extends PrimitiveBasisElement> IntSparseFormalSum<X> computeBoundary(IntSparseFormalSum<X> chain, IntAlgebraicFreeModule<X> chainModule) {
	IntSparseFormalSum<X> result = new IntSparseFormalSum<X>();

	if (chain == null) {
		System.out.println("null chain");
	}
	
	for (TObjectIntIterator<X> iterator = chain.iterator(); iterator.hasNext(); ) {
		iterator.advance();

		IntSparseFormalSum<X> boundary = createNewSum(iterator.key().getBoundaryCoefficients(), iterator.key().getBoundaryArray());
		chainModule.accumulate(result, boundary, iterator.value());
	}

	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public static <U extends PrimitiveBasisElement, V extends ObjectObjectPair<U, U>> ObjectObjectFunction<IntSparseFormalSum<V>, IntSparseFormalSum<U>> getFirstGradedProjectionMap(final IntAlgebraicFreeModule<U> chainModule, final IntAlgebraicFreeModule<V> dummy) {
	return new ObjectObjectFunction<IntSparseFormalSum<V>, IntSparseFormalSum<U>>() {

		public IntSparseFormalSum<U> evaluate(IntSparseFormalSum<V> chain) {

			if (chain.isEmpty()) {
				return chainModule.createNewSum();
			}

			int dimension = 0;

			{
				TObjectIntIterator<V> iterator = chain.iterator();

				if (iterator.hasNext()) {
					iterator.advance();
					dimension = iterator.key().getFirst().getDimension() + iterator.key().getSecond().getDimension();	
				}
			}

			return SimplexStreamUtility.filterByDimension(SimplexStreamUtility.projectFirst(chain, chainModule), dimension);
		}

	};
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public static <U extends PrimitiveBasisElement, V extends ObjectObjectPair<U, U>> ObjectObjectFunction<IntSparseFormalSum<V>, IntSparseFormalSum<U>> getSecondGradedProjectionMap(final IntAlgebraicFreeModule<U> chainModule, final IntAlgebraicFreeModule<V> dummy) {
	return new ObjectObjectFunction<IntSparseFormalSum<V>, IntSparseFormalSum<U>>() {

		public IntSparseFormalSum<U> evaluate(IntSparseFormalSum<V> chain) {

			if (chain.isEmpty()) {
				return chainModule.createNewSum();
			}

			int dimension = 0;

			{
				TObjectIntIterator<V> iterator = chain.iterator();

				if (iterator.hasNext()) {
					iterator.advance();
					dimension = iterator.key().getFirst().getDimension() + iterator.key().getSecond().getDimension();	
				}
			}

			return SimplexStreamUtility.filterByDimension(SimplexStreamUtility.projectSecond(chain, chainModule), dimension);
		}

	};
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public void removeFeatures(IIntIterator removedFeatures) {
    int shift = 0;
    int lastGoodFeature = 0;
    int totalFeatures = _featuresMap.size();
    TIntIntHashMap featuresRemap = new TIntIntHashMap();
    while (removedFeatures.hasNext()) {
        int removedFeature = removedFeatures.next();
        while (lastGoodFeature < removedFeature) {
            featuresRemap.put(lastGoodFeature, lastGoodFeature - shift);
            ++lastGoodFeature;
        }
        lastGoodFeature = removedFeature + 1;
        int removedFeaturePosition = removedFeature - shift;
        _featuresMap.remove(_featuresRMap.get(removedFeaturePosition));
        _featuresRMap.remove(removedFeaturePosition);
        ++shift;
    }

    while (lastGoodFeature < totalFeatures) {
        featuresRemap.put(lastGoodFeature, lastGoodFeature - shift);
        ++lastGoodFeature;
    }

    TObjectIntIterator<String> mapIter = _featuresMap.iterator();
    while (mapIter.hasNext()) {
        mapIter.advance();
        int value = mapIter.value();
        int newvalue = featuresRemap.get(value);
        mapIter.setValue(newvalue);
    }
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public IFeatureDB cloneDB() {
    TroveFeaturesDB featuresDB = new TroveFeaturesDB();
    featuresDB._name = new String(_name);

    TObjectIntIterator<String> iterator = _featuresMap.iterator();
    while (iterator.hasNext()) {
        iterator.advance();
        featuresDB._featuresMap.put(iterator.key(), iterator.value());
    }

    featuresDB._featuresRMap = (Vector<String>) _featuresRMap.clone();

    return featuresDB;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public String toString() {
  StringBuffer buffer = new StringBuffer();
  for( TObjectIntIterator<T> iter = myNumbers.iterator(); iter.hasNext(); ) {
    iter.advance();
    buffer.append(Integer.toString(iter.value()) + ": " + iter.key().toString() + "\n");
  }
  return buffer.toString();
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public static int buildFlags(GrModifierList modifierList) {
  int flags = 0;
  final TObjectIntIterator<String> iterator = GrModifierListImpl.NAME_TO_MODIFIER_FLAG_MAP.iterator();
  while (iterator.hasNext()) {
    iterator.advance();
    if (modifierList.hasExplicitModifier(iterator.key())) {
      flags |= iterator.value();
    }
  }
  return flags;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * If {@code this} is a {@link IntCounterMap} of the form <code> { a => { b => c } } </code>,
 * returns a new {@link IntCounterMap} of the form <code> { b => {c => # } } </code>
 * where for every {@code b}, {@code #} is the number of {@code a}'s for which {@code this[a][b]==c }
 */
public IntCounterMap<L,Integer> getAggregateHistogram() {
	IntCounterMap<L,Integer> aggregateHistogram = new IntCounterMap<L,Integer>();
	for (IntCounter<L> counter : this.values()) {
		for (TObjectIntIterator<L> iter = counter.getIterator();
				iter.hasNext();) {
			iter.advance();
			L key = iter.key();
			int value = iter.value();
			aggregateHistogram.increment(key, value);
		}
	}
	return aggregateHistogram;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public void incrementAllBy(int delta) {
	for (TObjectIntIterator<T> iter = getIterator();
			iter.hasNext();) {
		iter.advance();
		this.incrementBy(iter.key(), delta);
	}
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/** 
 * Returns a new counter containing only keys with nonzero values in 
 * at least one of the provided counters. Each key's value is the 
 * number of counters in which it occurs.
 */
public static <T> IntCounter<T> or(Collection<IntCounter<? extends T>> counters) {
	IntCounter<T> result = new IntCounter<T>();
	for (IntCounter<? extends T> counter : counters) {
		for (TObjectIntIterator<? extends T> iter = counter.getIterator();
				iter.hasNext();) {
			iter.advance();
			if (iter.value()!=0)
				result.increment(iter.key());
		}
	}
	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/** 
 * Returns a new counter containing only keys with nonzero values in 
 * both this and 'that'. Each key's value is the sum of its corresponding 
 * values in this and 'that'.
 */
public IntCounter<T> andWith(IntCounter<T> that) {
	IntCounter<T> result = new IntCounter<T>();
	for (TObjectIntIterator<T> iter = this.getIterator();
			iter.hasNext();) {
		iter.advance();
		if (iter.value()!=0 && that.getCount(iter.key())!=0)
			result.set(iter.key(), iter.value() + that.getCount(iter.key()));
	}
	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * @param factor Scaling factor to be multiplied by each value in this counter
 * @return A new Counter instance equivalent to this one, but with scaled values
 */
public IntCounter<T> scaleBy(int factor) {
	IntCounter<T> result = new IntCounter<T>();
	for (TObjectIntIterator<T> iter = getIterator();
			iter.hasNext();) {
		iter.advance();
		result.set(iter.key(), iter.value() * factor);
	}
	if (containsKey(null))
		result.set(null, getT(null)*factor);
	return result;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
/**
 * @return A map from unique values in this IntCounter to the number of distinct keys with which they are associated
 */
public IntCounter<Integer> getHistogram() {
	IntCounter<Integer> histogram = new IntCounter<Integer>();
	for (TObjectIntIterator<T> iter = getIterator();
			iter.hasNext();) {
		iter.advance();
		int value = iter.value();
		histogram.increment(value);
	}
	if (containsKey(null))
		histogram.increment(getT(null));
	return histogram;
}
 

import gnu.trove.TObjectIntIterator; //导入依赖的package包/类
public Counter<T> toCounter() {
	TObjectDoubleHashMap<T> map = new TObjectDoubleHashMap<T>();
	for (TObjectIntIterator<T> iter = getIterator();
			iter.hasNext();) {
		iter.advance();
		map.put(iter.key(), (double)iter.value());
	}
	if (containsKey(null))
		map.put(null, (double)getT(null));
	return new Counter<T>(map);
}