Example usage for com.google.common.collect TreeMultiset TreeMultiset

List of usage examples for com.google.common.collect TreeMultiset TreeMultiset

Introduction

In this page you can find the example usage for com.google.common.collect TreeMultiset TreeMultiset.

Prototype

TreeMultiset

Source Link

Usage

From source file:org.cspoker.ai.bots.bot.gametree.rollout.BucketRollOut.java

public double doRollOut(int nbCommunitySamples) {
    boolean traceEnabled = logger.isTraceEnabled();
    double totalEV = 0;
    model.assumeTemporarily(gameState);//from  w  w w .  j ava  2 s.  c o  m
    for (int i = 0; i < nbCommunitySamples; i++) {
        int communitySampleRank = fixedRank;
        EnumSet<Card> usedCommunityAndBotCards = EnumSet.copyOf(usedFixedCommunityAndBotCards);
        EnumSet<Card> usedCommunityCards = EnumSet.copyOf(usedFixedCommunityCards);
        for (int j = 0; j < nbMissingCommunityCards; j++) {
            Card communityCard = drawNewCard(usedCommunityAndBotCards);
            if (traceEnabled) {
                logger.trace("Evaluating sampled community card " + communityCard);
            }
            usedCommunityCards.add(communityCard);
            communitySampleRank = updateIntermediateRank(communitySampleRank, communityCard);
        }
        if (traceEnabled) {
            logger.trace("Evaluating bot cards " + botCard1 + " " + botCard2);
        }
        int botRank = getFinalRank(communitySampleRank, botCard1, botCard2);

        //         int minSampleRank = Integer.MAX_VALUE;
        //         int maxSampleRank = Integer.MIN_VALUE;
        //         int sum = 0;
        Multiset<Integer> ranks = new TreeMultiset<Integer>();
        Multiset<Integer> deadRanks = new TreeMultiset<Integer>();
        int n = 100;
        for (int j = 0; j < n; j++) {
            EnumSet<Card> handCards = EnumSet.copyOf(usedCommunityCards);
            Card sampleCard1 = drawNewCard(handCards);
            Card sampleCard2 = drawNewCard(handCards);
            int sampleRank = getFinalRank(communitySampleRank, sampleCard1, sampleCard2);
            ranks.add(sampleRank);
            if (botCard1.equals(sampleCard1) || botCard1.equals(sampleCard2) || botCard2.equals(sampleCard1)
                    || botCard2.equals(sampleCard2)) {
                deadRanks.add(sampleRank);
            }
            //            if(sampleRank<minSampleRank){
            //               minSampleRank = sampleRank;
            //            }
            //            if(sampleRank>maxSampleRank){
            //               maxSampleRank = sampleRank;
            //            }
            //            sum += sampleRank;
        }
        //         double mean = ((double)sum)/n;
        //         double var = calcVariance(ranks, mean);
        //         int averageSampleRank = (int) Math.round(mean);
        //         int sigmaSampleRank = (int) Math.round(Math.sqrt(var));

        WinDistribution[] winProbs = calcWinDistributions(botRank, ranks, deadRanks);
        double[] deadCardWeights = calcDeadCardWeights(ranks, deadRanks);

        TreeMap<PlayerState, WinDistribution> winDistributions = calcOpponentWinDistributionMap(winProbs,
                deadCardWeights);

        int maxDistributed = 0;
        int botInvestment = botState.getTotalInvestment();
        double sampleEV = 0;
        for (Iterator<PlayerState> iter = winDistributions.keySet().iterator(); iter.hasNext();) {
            PlayerState opponent = iter.next();
            int toDistribute = Math.min(botInvestment, opponent.getTotalInvestment()) - maxDistributed;
            if (toDistribute > 0) {
                double pWin = 1;
                double pNotLose = 1;
                for (WinDistribution distribution : winDistributions.values()) {
                    //you win when you win from every opponent
                    pWin *= distribution.pWin;
                    //you don't lose when you don't lose from every opponent
                    pNotLose *= distribution.pWin + distribution.pDraw;
                }
                sampleEV += toDistribute * pWin;
                //you draw when you don't lose but don't win everything either;
                double pDraw = pNotLose - pWin;
                // assume worst case, with winDistributions.size()+1 drawers
                //TODO do this better, use rollout or statistics!
                sampleEV += pDraw * toDistribute / (winDistributions.size() + 1.0);
                maxDistributed += toDistribute;
            }
            iter.remove();
        }
        //get back uncalled investment
        sampleEV += botInvestment - maxDistributed;
        totalEV += sampleEV;
    }
    model.forgetLastAssumption();
    return (1 - gameState.getTableConfiguration().getRake()) * (totalEV / nbCommunitySamples);
}

From source file:bots.mctsbot.ai.bots.bot.gametree.rollout.BucketRollOut.java

public double doRollOut(int nbCommunitySamples) {
    boolean traceEnabled = logger.isTraceEnabled();
    double totalEV = 0;
    model.assumeTemporarily(gameState);/*from w ww . ja va 2  s . c om*/
    for (int i = 0; i < nbCommunitySamples; i++) {
        int communitySampleRank = fixedRank;
        Set<Integer> usedCommunityAndBotCards = new TreeSet<Integer>(usedFixedCommunityAndBotCards);
        Set<Integer> usedCommunityCards = new TreeSet<Integer>();
        for (int card = 0; card < usedFixedCommunityCards.size(); card++) {
            usedCommunityCards.add(usedFixedCommunityCards.getCardIndex(card + 1));
        }

        for (int j = 0; j < nbMissingCommunityCards; j++) {
            Integer communityCard = drawNewCard(usedCommunityAndBotCards);
            if (traceEnabled) {
                logger.trace("Evaluating sampled community card " + communityCard);
            }
            usedCommunityCards.add(communityCard);
            communitySampleRank = updateIntermediateRank(communitySampleRank, new Card(communityCard));
        }
        if (traceEnabled) {
            logger.trace("Evaluating bot cards " + botCard1 + " " + botCard2);
        }
        int botRank = getFinalRank(communitySampleRank, botCard1, botCard2);

        //         int minSampleRank = Integer.MAX_VALUE;
        //         int maxSampleRank = Integer.MIN_VALUE;
        //         int sum = 0;
        Multiset<Integer> ranks = new TreeMultiset<Integer>();
        Multiset<Integer> deadRanks = new TreeMultiset<Integer>();
        int n = 100;
        for (int j = 0; j < n; j++) {
            Set<Integer> handCards = new TreeSet<Integer>(usedCommunityCards);
            Integer sampleCard1 = drawNewCard(handCards);
            Integer sampleCard2 = drawNewCard(handCards);
            int sampleRank = getFinalRank(communitySampleRank, new Card(sampleCard1), new Card(sampleCard2));
            ranks.add(sampleRank);
            if (botCard1.equals(sampleCard1) || botCard1.equals(sampleCard2) || botCard2.equals(sampleCard1)
                    || botCard2.equals(sampleCard2)) {
                deadRanks.add(sampleRank);
            }
            //            if(sampleRank<minSampleRank){
            //               minSampleRank = sampleRank;
            //            }
            //            if(sampleRank>maxSampleRank){
            //               maxSampleRank = sampleRank;
            //            }
            //            sum += sampleRank;
        }
        //         double mean = ((double)sum)/n;
        //         double var = calcVariance(ranks, mean);
        //         int averageSampleRank = (int) Math.round(mean);
        //         int sigmaSampleRank = (int) Math.round(Math.sqrt(var));

        WinDistribution[] winProbs = calcWinDistributions(botRank, ranks, deadRanks);
        double[] deadCardWeights = calcDeadCardWeights(ranks, deadRanks);

        TreeMap<PlayerState, WinDistribution> winDistributions = calcOpponentWinDistributionMap(winProbs,
                deadCardWeights);

        int maxDistributed = 0;
        int botInvestment = botState.getTotalInvestment();
        double sampleEV = 0;
        for (Iterator<PlayerState> iter = winDistributions.keySet().iterator(); iter.hasNext();) {
            PlayerState opponent = iter.next();
            int toDistribute = Math.min(botInvestment, opponent.getTotalInvestment()) - maxDistributed;
            if (toDistribute > 0) {
                double pWin = 1;
                double pNotLose = 1;
                for (WinDistribution distribution : winDistributions.values()) {
                    //you win when you win from every opponent
                    pWin *= distribution.pWin;
                    //you don't lose when you don't lose from every opponent
                    pNotLose *= distribution.pWin + distribution.pDraw;
                }
                sampleEV += toDistribute * pWin;
                //you draw when you don't lose but don't win everything either;
                double pDraw = pNotLose - pWin;
                // assume worst case, with winDistributions.size()+1 drawers
                //TODO do this better, use rollout or statistics!
                sampleEV += pDraw * toDistribute / (winDistributions.size() + 1.0);
                maxDistributed += toDistribute;
            }
            iter.remove();
        }
        //get back uncalled investment
        sampleEV += botInvestment - maxDistributed;
        totalEV += sampleEV;
    }
    model.forgetLastAssumption();
    return (1 - gameState.getTableConfiguration().getRake()) * (totalEV / nbCommunitySamples);
}

From source file:org.cspoker.ai.opponentmodels.weka.Propositionalizer.java

public void signalCardShowdown(Object id, Card card1, Card card2) {
    //      PlayerData p = players.get(id);
    if (cards.size() == 5) {
        //showdown after river
        Multiset<Integer> ranks = new TreeMultiset<Integer>();
        //         int minSampleRank = Integer.MAX_VALUE;
        //         int maxSampleRank = Integer.MIN_VALUE;
        //         int sum = 0;

        int startRank = 53;
        for (Card card : cards) {
            startRank = handRanks[card.ordinal() + 1 + startRank];
        }//from w  w  w .ja va 2  s . c o m

        //add real rank
        int realRank = startRank;
        realRank = handRanks[card1.ordinal() + 1 + realRank];
        realRank = handRanks[card2.ordinal() + 1 + realRank];
        int realType = (realRank >>> 12) - 1;
        realRank = realRank & 0xFFF;
        realRank = offsets[realType] + realRank - 1;

        //take rank samples
        int nbBuckets = 6;
        int nbSamplesPerBucket = 6;
        int nbSamples = nbBuckets * nbSamplesPerBucket;
        for (int i = 0; i < nbSamples; i++) {

            int rank = startRank;
            Card sampleCard1;
            do {
                sampleCard1 = Card.values()[random.nextInt(Card.values().length)];
            } while (cards.contains(sampleCard1));
            rank = handRanks[sampleCard1.ordinal() + 1 + rank];

            Card sampleCard2;
            do {
                sampleCard2 = Card.values()[random.nextInt(Card.values().length)];
            } while (cards.contains(sampleCard2) || sampleCard2.equals(sampleCard1));
            rank = handRanks[sampleCard2.ordinal() + 1 + rank];

            int type = (rank >>> 12) - 1;
            rank = rank & 0xFFF;
            rank = offsets[type] + rank - 1;

            ranks.add(rank);

            //            if(rank<minSampleRank){
            //               minSampleRank = rank;
            //            }
            //            if(rank>maxSampleRank){
            //               maxSampleRank = rank;
            //            }
            //            sum += rank;
        }
        //         double var = 0;
        //         double mean = ((double)sum)/nbSamples;
        //         for (Multiset.Entry<Integer> entry : ranks.entrySet()) {
        //            double diff = mean - entry.getElement();
        //            var += diff * diff * entry.getCount();
        //         }
        //         var /= (nbSamples-1);
        //         int averageSampleRank = (int) Math.round(mean);
        //         int sigmaSampleRank = (int) Math.round(Math.sqrt(var));
        int[] bucketCounts = new int[nbBuckets];
        Iterator<Integer> iter = ranks.iterator();
        double realRankCount = ranks.count(realRank);
        //         long avgBucket = -1;
        double[] bucketDistr = new double[nbBuckets];
        if (realRankCount > 0) {
            for (int bucket = 0; bucket < nbBuckets; bucket++) {
                for (int i = 0; i < nbSamplesPerBucket; i++) {
                    int rank = iter.next();
                    if (rank == realRank) {
                        ++bucketCounts[bucket];
                    }
                }
            }
            int partitionSum = 0;
            for (int i = 0; i < nbBuckets; i++) {
                bucketDistr[i] = bucketCounts[i] / realRankCount;
                partitionSum += bucketCounts[i] * i;
            }
            //         avgBucket = Math.round(partitionSum/realRankCount);
        } else {
            boolean found = false;
            bucketIteration: for (int bucket = 0; bucket < nbBuckets; bucket++) {
                for (int i = 0; i < nbSamplesPerBucket; i++) {
                    int rank = iter.next();
                    if (rank > realRank) {
                        bucketDistr[bucket] = 1;
                        //            avgBucket = bucket;
                        found = true;
                        break bucketIteration;
                    }
                }
            }
            if (!found) {
                bucketCounts[nbBuckets - 1] = 1;
                //            avgBucket = nbBuckets-1;
            }
        }
        logShowdown(id, bucketDistr);
    } else {
        //ignore
        //throw new IllegalStateException("everybody went all-in before the river");
    }
}

From source file:bots.mctsbot.ai.opponentmodels.weka.Propositionalizer.java

public void signalCardShowdown(Object id, Card card1, Card card2) {
    //      PlayerData p = players.get(id);
    if (cards.size() == 5) {
        //showdown after river
        Multiset<Integer> ranks = new TreeMultiset<Integer>();
        //         int minSampleRank = Integer.MAX_VALUE;
        //         int maxSampleRank = Integer.MIN_VALUE;
        //         int sum = 0;

        int startRank = 53;
        for (int i = 0; i < cards.size(); i++) {
            startRank = handRanks[CardConverter.toSpears2p2Index(cards.getCard(i + 1)) + startRank];
        }//from  w ww  .ja va2 s .c o  m

        //add real rank
        int realRank = startRank;
        realRank = handRanks[CardConverter.toSpears2p2Index(card1) + realRank];
        realRank = handRanks[CardConverter.toSpears2p2Index(card2) + realRank];
        int realType = (realRank >>> 12) - 1;
        realRank = realRank & 0xFFF;
        realRank = offsets[realType] + realRank - 1;

        //take rank samples
        int nbBuckets = 6;
        int nbSamplesPerBucket = 6;
        int nbSamples = nbBuckets * nbSamplesPerBucket;
        for (int i = 0; i < nbSamples; i++) {

            int rank = startRank;
            Card sampleCard1;
            do {
                sampleCard1 = new Card(random.nextInt(52));
            } while (cards.contains(sampleCard1));
            rank = handRanks[CardConverter.toSpears2p2Index(sampleCard1) + rank];

            Card sampleCard2;
            do {
                sampleCard2 = new Card(random.nextInt(52));
            } while (cards.contains(sampleCard2) || sampleCard2.equals(sampleCard1));
            rank = handRanks[CardConverter.toSpears2p2Index(sampleCard2) + rank];

            int type = (rank >>> 12) - 1;
            rank = rank & 0xFFF;
            rank = offsets[type] + rank - 1;

            ranks.add(rank);

            //            if(rank<minSampleRank){
            //               minSampleRank = rank;
            //            }
            //            if(rank>maxSampleRank){
            //               maxSampleRank = rank;
            //            }
            //            sum += rank;
        }
        //         double var = 0;
        //         double mean = ((double)sum)/nbSamples;
        //         for (Multiset.Entry<Integer> entry : ranks.entrySet()) {
        //            double diff = mean - entry.getElement();
        //            var += diff * diff * entry.getCount();
        //         }
        //         var /= (nbSamples-1);
        //         int averageSampleRank = (int) Math.round(mean);
        //         int sigmaSampleRank = (int) Math.round(Math.sqrt(var));
        int[] bucketCounts = new int[nbBuckets];
        Iterator<Integer> iter = ranks.iterator();
        double realRankCount = ranks.count(realRank);
        //         long avgBucket = -1;
        double[] bucketDistr = new double[nbBuckets];
        if (realRankCount > 0) {
            for (int bucket = 0; bucket < nbBuckets; bucket++) {
                for (int i = 0; i < nbSamplesPerBucket; i++) {
                    int rank = iter.next();
                    if (rank == realRank) {
                        ++bucketCounts[bucket];
                    }
                }
            }
            int partitionSum = 0;
            for (int i = 0; i < nbBuckets; i++) {
                bucketDistr[i] = bucketCounts[i] / realRankCount;
                partitionSum += bucketCounts[i] * i;
            }
            //         avgBucket = Math.round(partitionSum/realRankCount);
        } else {
            boolean found = false;
            bucketIteration: for (int bucket = 0; bucket < nbBuckets; bucket++) {
                for (int i = 0; i < nbSamplesPerBucket; i++) {
                    int rank = iter.next();
                    if (rank > realRank) {
                        bucketDistr[bucket] = 1;
                        //            avgBucket = bucket;
                        found = true;
                        break bucketIteration;
                    }
                }
            }
            if (!found) {
                bucketCounts[nbBuckets - 1] = 1;
                //            avgBucket = nbBuckets-1;
            }
        }
        logShowdown(id, bucketDistr);
    } else {
        //ignore
        //throw new IllegalStateException("everybody went all-in before the river");
    }
}