Java TIntIntHashMap.containsKey方法代碼示例

import gnu.trove.map.hash.TIntIntHashMap; //導入方法依賴的package包/類
private boolean notUseAfterLastDef(int reg,
        MachineBasicBlock mbb,
        int dist,
        TIntIntHashMap distanceMap,
        OutParamWrapper<Integer> lastDef)
{
    lastDef.set(0);
    int lastUse = dist;
    for (DefUseChainIterator itr = mri.getRegIterator(reg); itr.hasNext();)
    {
        MachineOperand mo = itr.getOpearnd();
        MachineInstr mi = itr.getMachineInstr();
        if (!mi.getParent().equals(mbb))
            continue;
        if (!distanceMap.containsKey(mi.index()))
            continue;

        if (mo.isUse() && distanceMap.get(mi.index()) < lastUse)
            lastUse = distanceMap.get(mi.index());
        if (mo.isDef() && distanceMap.get(mi.index()) > lastDef.get())
            lastDef.set(distanceMap.get(mi.index()));
        itr.next();
    }
    return (!(lastUse > lastDef.get() && lastUse < dist));
}
 

import gnu.trove.map.hash.TIntIntHashMap; //導入方法依賴的package包/類
private boolean isProfitableToReMat(int reg,
        TargetRegisterClass rc,
        MachineInstr mi,
        MachineInstr defMI,
        MachineBasicBlock mbb,
        int loc,
        TIntIntHashMap distanceMap)
{
    boolean otherUse = false;
    for (DefUseChainIterator itr = mri.getUseIterator(reg); itr.hasNext(); )
    {
        MachineOperand useMO = itr.getOpearnd();
        MachineInstr useMI = itr.getMachineInstr();
        MachineBasicBlock useBB = useMI.getParent();
        if (useBB.equals(mbb))
        {
            int idx = useMI.index();
            if (distanceMap.containsKey(idx) && distanceMap.get(idx) == loc)
            {
                otherUse = true;
                if (isTwoAddrUse(useMI, reg))
                    return true;
            }
        }
    }

    if (otherUse)
        return false;

    return mbb.equals(defMI.getParent());
}
 

import gnu.trove.map.hash.TIntIntHashMap; //導入方法依賴的package包/類
@Override
public boolean runOnMachineFunction(MachineFunction mf)
{
    this.mf = mf;
    ec = new IntEqClasses(mf.getNumBlockIDs()*2);
    for (MachineBasicBlock mbb : mf.getBasicBlocks())
    {
        int outEdge = mbb.getNumber()*2 + 1;
        // Join the outgoing
        for (Iterator<MachineBasicBlock> itr = mbb.succIterator(); itr.hasNext(); )
        {
            ec.join(outEdge, itr.next().getNumber()*2);
        }
    }
    blocks = new TIntArrayList[getNumBundles()];
    for (int i = 0, e; i < getNumBundles(); i++)
        blocks[i] = new TIntArrayList();

    groupID = new TIntIntHashMap();
    for (int i = 0; i < ec.getNumIds(); i++)
    {
        int leading = ec.findLeader(i);
        if (!groupID.containsKey(leading))
            groupID.put(leading, nextID++);
    }

    for (int i = 0, e = mf.getNumBlockIDs(); i < e; i++)
    {
        int b0 = getBundles(i, false);
        int b1 = getBundles(i, true);
        blocks[b0].add(i);
        if (b1 != b0)
            blocks[b1].add(i);
    }
    nextID = 0;
    return false;
}
 

import gnu.trove.map.hash.TIntIntHashMap; //導入方法依賴的package包/類
public boolean contains(final String groupId, final int timepoint) {
	final TIntIntHashMap countResult = countResults.get(groupId);
	if (countResult == null) {
		return false;
	} else {
		return countResult.containsKey(timepoint);
	}
}
 

import gnu.trove.map.hash.TIntIntHashMap; //導入方法依賴的package包/類
private void buildFeatureVector(int item_id, TIntIntHashMap paths) {

        try {
            double rate = 0;
            double n = 1;
            boolean training = false, validation = false;
            DecimalFormat form = new DecimalFormat("#.####");
            form.setRoundingMode(RoundingMode.CEILING);
            StringBuffer str = new StringBuffer();

            if (trainRatings.containsKey(item_id)) {
                training = true;
                rate = trainRatings.get(item_id);
            } else if (validationRatings.containsKey(item_id)) {
                validation = true;
                rate = validationRatings.get(item_id);
            }

            if (normalize)
                n = norm(paths);

            str.append(rate + " qid:" + user_id + " 1:" + item_id + " ");

            for (int i = 1; i <= path_index.size(); i++) {

                int count = 0;

                if (paths.size() == 1)
                    n = norm(paths);

                if (paths.containsKey(i)) {

                    count = paths.get(i);

                    if (normalize)
                        str.append(i + 1 + ":"
                                + form.format(count / n).replace(",", ".")
                                + " ");
                    else
                        str.append(i + 1 + ":" + count + " ");

                }
            }

            if (training) {
                synchronized (train_file) {
                    train_file.append(str);
                    train_file.newLine();
                }
            } else if (validation) {
                synchronized (validation_file) {
                    validation_file.append(str);
                    validation_file.newLine();
                }
            } else {
                synchronized (test_file) {
                    test_file.append(str);
                    test_file.newLine();
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 

import gnu.trove.map.hash.TIntIntHashMap; //導入方法依賴的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.map.hash.TIntIntHashMap; //導入方法依賴的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.map.hash.TIntIntHashMap; //導入方法依賴的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;
    }