Java TIntHashSet.iterator方法代码示例

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
@Override
public void save(@NotNull DataOutput out, TIntHashSet value) throws IOException {
  out.writeInt(value.size());
  final TIntIterator iterator = value.iterator();
  while (iterator.hasNext()) {
    out.writeInt(iterator.next());
  }
}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
/** What is the probability that these two observations were drawn from
	 *	the same multinomial with symmetric Dirichlet prior alpha, relative 
	 *	to the probability that they were drawn from different multinomials
	 *	both drawn from this Dirichlet?
	 */
	public static double dirichletMultinomialLikelihoodRatio(TIntIntHashMap countsX,
			TIntIntHashMap countsY,
			double alpha, double alphaSum) {
//		The likelihood for one DCM is 
//		Gamma( alpha_sum )	 prod Gamma( alpha + N_i )
//		prod Gamma ( alpha )   Gamma ( alpha_sum + N )

//		When we divide this by the product of two other DCMs with the same
//		alpha parameter, the first term in the numerator cancels with the 
//		first term in the denominator. Then moving the remaining alpha-only
//		term to the numerator, we get
//		prod Gamma(alpha)	  prod Gamma( alpha + X_i + Y_i )
//		Gamma (alpha_sum)	 Gamma( alpha_sum + X_sum + Y_sum )
//		----------------------------------------------------------
//		prod Gamma(alpha + X_i)		  prod Gamma(alpha + Y_i)
//		Gamma( alpha_sum + X_sum )	  Gamma( alpha_sum + Y_sum )


		double logLikelihood = 0.0;
		double logGammaAlpha = logGamma(alpha);

		int totalX = 0;
		int totalY = 0;

		int key, x, y;

		TIntHashSet distinctKeys = new TIntHashSet();
		distinctKeys.addAll(countsX.keys());
		distinctKeys.addAll(countsY.keys());

		TIntIterator iterator = distinctKeys.iterator();
		while (iterator.hasNext()) {
			key = iterator.next();

			x = 0;
			if (countsX.containsKey(key)) {
				x = countsX.get(key);
			}

			y = 0;
			if (countsY.containsKey(key)) {
				y = countsY.get(key);
			}

			totalX += x;
			totalY += y;

			logLikelihood += logGamma(alpha) + logGamma(alpha + x + y)
			- logGamma(alpha + x) - logGamma(alpha + y);
		}

		logLikelihood += logGamma(alphaSum + totalX) + logGamma(alphaSum + totalY) 
		- logGamma(alphaSum) - logGamma(alphaSum + totalX + totalY);

		return logLikelihood;
	}
 

import gnu.trove.TIntHashSet; //导入方法依赖的package包/类
@NotNull
public static TIntArrayList findParametersToRemove(@NotNull PsiMethod method,
                                                   @NotNull final PsiExpression expr,
                                                   @Nullable final PsiExpression[] occurences) {
  final PsiParameter[] parameters = method.getParameterList().getParameters();
  if (parameters.length == 0) return new TIntArrayList();

  PsiMethod[] overridingMethods = OverridingMethodsSearch.search(method, true).toArray(PsiMethod.EMPTY_ARRAY);
  final PsiMethod[] allMethods = ArrayUtil.append(overridingMethods, method);

  final TIntHashSet suspects = new TIntHashSet();
  expr.accept(new JavaRecursiveElementWalkingVisitor() {
    @Override public void visitReferenceExpression(final PsiReferenceExpression expression) {
      super.visitReferenceExpression(expression);
      PsiElement resolved = expression.resolve();
      if (resolved instanceof PsiParameter) {
        int i = ArrayUtil.find(parameters, resolved);
        if (i != -1) {
          suspects.add(i);
        }
      }
    }
  });

  final TIntIterator iterator = suspects.iterator();
  while(iterator.hasNext()) {
    final int paramNum = iterator.next();
    for (PsiMethod psiMethod : allMethods) {
      PsiParameter[] psiParameters = psiMethod.getParameterList().getParameters();
      if (paramNum >= psiParameters.length) continue;
      PsiParameter parameter = psiParameters[paramNum];
      if (!ReferencesSearch.search(parameter, parameter.getResolveScope(), false).forEach(new Processor<PsiReference>() {
        public boolean process(final PsiReference reference) {
          PsiElement element = reference.getElement();
          boolean stillCanBeRemoved = false;
          if (element != null) {
            stillCanBeRemoved = isAncestor(expr, element, false) || PsiUtil.isInsideJavadocComment(getPhysical(element));
            if (!stillCanBeRemoved && occurences != null) {
              for (PsiExpression occurence : occurences) {
                if (isAncestor(occurence, element, false)) {
                  stillCanBeRemoved = true;
                  break;
                }
              }
            }
          }
          if (!stillCanBeRemoved) {
            iterator.remove();
            return false;
          }
         return true;
        }
      })) break;
    }
  }

  return new TIntArrayList(suspects.toArray());
}