dleshem/simulateEdge.js

## simulateEdge.js
const d3 = require('d3-array');
const Combinatorics = require('js-combinatorics');
const OddsCalculator = require('cardplayer-odds-calculator');
const PromiseThrottle = require('promise-throttle');

const oddsCalculator = new OddsCalculator({timeout: 30000});

const odds = async (holes, dead = []) => {
    switch(holes[0].length) {
        case 2: return oddsCalculator.texasHoldem({holes, dead});
        case 4: return oddsCalculator.omahaHoldem({holes, dead});
        default: throw new Error(`${holes[0].length} hole cards are not supported`);
    }
};

const promiseThrottle = new PromiseThrottle({
    requestsPerSecond: 3,
    promiseImplementation: Promise
});

const calcEv2 = ({win, lose, tie}) => (win + tie/2) / (win + lose + tie);

const stringifyHole = hole => hole.join('');

const sample = async (deck, holeCards, players) => {
    d3.shuffle(deck);

    const indices = [...Array(players)].map((_, i) => i);
    const holes = indices.map(i => deck.slice(i*holeCards, (i+1)*holeCards));

    const options = [];
    let playersPart;
    const playersCmb = Combinatorics.combination(indices, 2);
    while (playersPart = playersCmb.next()) {
        const twoHoles = [];
        const dead = [];
        for (let i = 0; i < players; ++i) {
            if ((i === playersPart[0]) || (i === playersPart[1])) {
                twoHoles.push(holes[i]);
            } else {
                dead.push(holes[i][0]);
                dead.push(holes[i][1]);
            }
        }

        options.push({
            index1: playersPart[0],
            index2: playersPart[1],
            twoHoles,
            futureAssumedOdds: promiseThrottle.add(odds.bind(this, twoHoles)),
            futureRealOdds: promiseThrottle.add(odds.bind(this, twoHoles, dead))
        });
    }

    const results = [];
    const best = {edge: 0};
    for (let i = 0; i < options.length; ++i) {
        const option = options[i];

        const assumedEV = calcEv2((await option.futureAssumedOdds)[0]);
        const realEV = calcEv2((await option.futureRealOdds)[0]);
        const edge = Math.round(10000*Math.abs(assumedEV - realEV))/10000;

        results.push({
            index1: option.index1,
            index2: option.index2,
            twoHoles: option.twoHoles,
            assumedEV,
            realEV,
            edge
        });

        if (edge > best.edge) {
            best.index1 = option.index1,
            best.index2 = option.index2,
            best.edge = edge;
            best.twoHoles = option.twoHoles;
            best.assumedEV = assumedEV;
            best.realEV = realEV;
        }
    }

    // Print
    console.log(holes);
    results.forEach(({twoHoles, assumedEV, realEV, edge}) => {
        console.log(`${stringifyHole(twoHoles[0])} vs ${stringifyHole(twoHoles[1])}: assumed: ${assumedEV}, actual: ${realEV}}, edge: ${edge}`);
    });
    console.log('------------');
    console.log(`${stringifyHole(best.twoHoles[0])} vs ${stringifyHole(best.twoHoles[1])} has best edge: ${best.edge}`);

    return best;
};

////////////////////////////////////////

const players = 10;
const holeCards = 2;

const deck = Combinatorics.cartesianProduct(['2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'], ['s', 'c', 'd', 'h']).map(x => x.join(''));

(async () => {
    try {
        await sample(deck, holeCards, players);
    } catch (e) {}
})();

## simulateStrategy.js
const d3 = require('d3-array');
const Combinatorics = require('js-combinatorics');
const OddsCalculator = require('cardplayer-odds-calculator');
const PromiseThrottle = require('promise-throttle');

const oddsCalculator = new OddsCalculator({timeout: 30000});

const odds = async (holes, dead = []) => {
    switch(holes[0].length) {
        case 2: return oddsCalculator.texasHoldem({holes, dead});
        case 4: return oddsCalculator.omahaHoldem({holes, dead});
        default: throw new Error(`${holes[0].length} hole cards are not supported`);
    }
};

const promiseThrottle = new PromiseThrottle({
    requestsPerSecond: 3,
    promiseImplementation: Promise
});

const calcEv2 = ({win, lose, tie}) => (win + tie/2) / (win + lose + tie);

const stringifyHole = hole => hole.join('');

const sample = async (deck, holeCards, players) => {
    d3.shuffle(deck);

    const indices = [...Array(players)].map((_, i) => i);
    const holes = indices.map(i => deck.slice(i*holeCards, (i+1)*holeCards));

    const options = [];
    let playersPart;
    const playersCmb = Combinatorics.combination(indices, 2);
    while (playersPart = playersCmb.next()) {
        const twoHoles = [];
        const dead = [];
        for (let i = 0; i < players; ++i) {
            if ((i === playersPart[0]) || (i === playersPart[1])) {
                twoHoles.push(holes[i]);
            } else {
                dead.push(holes[i][0]);
                dead.push(holes[i][1]);
            }
        }

        options.push({
            index1: playersPart[0],
            index2: playersPart[1],
            twoHoles,
            futureAssumedOdds: promiseThrottle.add(odds.bind(this, twoHoles)),
            futureRealOdds: promiseThrottle.add(odds.bind(this, twoHoles, dead))
        });
    }

    const results = [];
    const best = {edge: 0};
    for (let i = 0; i < options.length; ++i) {
        const option = options[i];

        const assumedEV = calcEv2((await option.futureAssumedOdds)[0]);
        const realEV = calcEv2((await option.futureRealOdds)[0]);
        const edge = Math.round(10000*Math.abs(assumedEV - realEV))/10000;

        results.push({
            index1: option.index1,
            index2: option.index2,
            twoHoles: option.twoHoles,
            assumedEV,
            realEV,
            edge
        });

        if (edge > best.edge) {
            best.index1 = option.index1,
            best.index2 = option.index2,
            best.edge = edge;
            best.twoHoles = option.twoHoles;
            best.assumedEV = assumedEV;
            best.realEV = realEV;
        }
    }

    // Print
    console.log(holes);
    results.forEach(({twoHoles, assumedEV, realEV, edge}) => {
        console.log(`${stringifyHole(twoHoles[0])} vs ${stringifyHole(twoHoles[1])}: assumed: ${assumedEV}, actual: ${realEV}}, edge: ${edge}`);
    });
    console.log('------------');
    console.log(`${stringifyHole(best.twoHoles[0])} vs ${stringifyHole(best.twoHoles[1])} has best edge: ${best.edge}`);

    return best;
};

////////////////////////////////////////

// see https://www.pokerstars.com/poker/room/rake/
const rake = pot => Math.min(pot * 0.05, 2.5);

const players = 10;
const holeCards = 2;

const deck = Combinatorics.cartesianProduct(['2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'], ['s', 'c', 'd', 'h']).map(x => x.join(''));

const stacks = [];
for (let i = 0; i < players; ++i) {
    stacks[i] = 0;
}
let bankroll = 0;

(async () => {
    let hands = 0;
    while (true) {
        console.log(`hands = ${hands}`);
        ++hands;
        console.log(`Bankroll = ${bankroll}`);
        console.log(stacks);
        let total = bankroll;
        for (let i = 0; i < players; ++i) {
            total += stacks[i];
            const reload = Math.max(100 - stacks[i], 0);
            bankroll -= reload;
            stacks[i] += reload;
        }
        console.log(`total = ${total}`);

        let best;
        while (true) {
            try {
                best = await sample(deck, holeCards, players);
                break;
            } catch (e) {}
        }

        let allinIndex, cashoutIndex, cashoutOdds, allinOdds;
        if (best.realEV > best.assumedEV) {
            allinIndex = best.index1;
            cashoutIndex = best.index2;
            cashoutOdds = 1 - best.assumedEV;
            allinOdds = best.realEV;
        } else {
            allinIndex = best.index2;
            cashoutIndex = best.index1;
            cashoutOdds = best.assumedEV;
            allinOdds = 1 - best.realEV;
        }

        const effectiveAllin = Math.min(stacks[allinIndex], stacks[cashoutIndex]);
        stacks[allinIndex] -= effectiveAllin;
        stacks[cashoutIndex] -= effectiveAllin;
        const pot = (2 * effectiveAllin) - rake(2 * effectiveAllin);

        stacks[cashoutIndex] += pot * 0.99 * cashoutOdds;
        if (Math.random() < allinOdds) {
            stacks[allinIndex] += pot;
        }
    }
})();

## texas6-example.csv

          
            Hand 1
            Hand 2
            PokerStars
            Real
            Edge

            
              J♠Q♣
              A♣9♦
              42.65%
              39.74%
              2.92%

            
              J♠Q♣
              K♠9♣
              42.13%
              43.59%
              1.46%

            
              A♣9♦
              K♠9♣
              74.42%
              80.20%
              5.78%

            
              J♠Q♣
              T♠7♦
              67.63%
              62.05%
              5.58%

            
              A♣9♦
              T♠7♦
              61.56%
              57.88%
              3.68%

            
              K♠9♣
              T♠7♦
              62.61%
              54.35%
              8.26%

            
              J♠Q♣
              3♥Q♠
              73.32%
              70.02%
              3.30%

            
              A♣9♦
              3♥Q♠
              63.48%
              64.03%
              0.55%

            
              K♠9♣
              3♥Q♠
              64.81%
              61.10%
              3.70%

            
              T♠7♦
              3♥Q♠
              42.74%
              48.73%
              5.99%

            
              J♠Q♣
              K♦4♣
              44.48%
              43.97%
              0.51%

            
              A♣9♦
              K♦4♣
              63.83%
              64.90%
              1.07%

            
              K♠9♣
              K♦4♣
              69.93%
              65.45%
              4.48%

            
              T♠7♦
              K♦4♣
              42.55%
              48.56%
              6.01%

            
              3♥Q♠
              K♦4♣
              36.12%
              36.52%
              0.40%

## texas6-example.txt
╔═══════════╦════════════╦════════╦════════╗
║   Combo   ║ PokerStars ║  Real  ║  Edge  ║
╠═══════════╬════════════╬════════╬════════╣
║ J♠Q♣|A♣9♦ ║   42.65%   ║ 39.74% ║  2.92% ║
║ J♠Q♣|K♠9♣ ║   42.13%   ║ 43.59% ║  1.46% ║
║ A♣9♦|K♠9♣ ║   74.42%   ║ 80.20% ║  5.78% ║
║ J♠Q♣|T♠7♦ ║   67.63%   ║ 62.05% ║  5.58% ║
║ A♣9♦|T♠7♦ ║   61.56%   ║ 57.88% ║  3.68% ║
║ K♠9♣|T♠7♦ ║   62.61%   ║ 54.35% ║  8.26% ║ ← information edge
║ J♠Q♣|3♥Q♠ ║   73.32%   ║ 70.02% ║  3.30% ║
║ A♣9♦|3♥Q♠ ║   63.48%   ║ 64.03% ║  0.55% ║
║ K♠9♣|3♥Q♠ ║   64.81%   ║ 61.10% ║  3.70% ║
║ T♠7♦|3♥Q♠ ║   42.74%   ║ 48.73% ║  5.99% ║
║ J♠Q♣|K♦4♣ ║   44.48%   ║ 43.97% ║  0.51% ║
║ A♣9♦|K♦4♣ ║   63.83%   ║ 64.90% ║  1.07% ║
║ K♠9♣|K♦4♣ ║   69.93%   ║ 65.45% ║  4.48% ║
║ T♠7♦|K♦4♣ ║   42.55%   ║ 48.56% ║  6.01% ║
║ 3♥Q♠|K♦4♣ ║   36.12%   ║ 36.52% ║  0.40% ║
╚═══════════╩════════════╩════════╩════════╝
	const d3 = require('d3-array');
	const Combinatorics = require('js-combinatorics');
	const OddsCalculator = require('cardplayer-odds-calculator');
	const PromiseThrottle = require('promise-throttle');

	const oddsCalculator = new OddsCalculator({timeout: 30000});

	const odds = async (holes, dead = []) => {
	switch(holes[0].length) {
	case 2: return oddsCalculator.texasHoldem({holes, dead});
	case 4: return oddsCalculator.omahaHoldem({holes, dead});
	default: throw new Error(`${holes[0].length} hole cards are not supported`);
	}
	};

	const promiseThrottle = new PromiseThrottle({
	requestsPerSecond: 3,
	promiseImplementation: Promise
	});

	const calcEv2 = ({win, lose, tie}) => (win + tie/2) / (win + lose + tie);

	const stringifyHole = hole => hole.join('');

	const sample = async (deck, holeCards, players) => {
	d3.shuffle(deck);

	const indices = [...Array(players)].map((_, i) => i);
	const holes = indices.map(i => deck.slice(iholeCards, (i+1)holeCards));

	const options = [];
	let playersPart;
	const playersCmb = Combinatorics.combination(indices, 2);
	while (playersPart = playersCmb.next()) {
	const twoHoles = [];
	const dead = [];
	for (let i = 0; i < players; ++i) {
	if ((i === playersPart[0]) \|\| (i === playersPart[1])) {
	twoHoles.push(holes[i]);
	} else {
	dead.push(holes[i][0]);
	dead.push(holes[i][1]);
	}
	}

	options.push({
	index1: playersPart[0],
	index2: playersPart[1],
	twoHoles,
	futureAssumedOdds: promiseThrottle.add(odds.bind(this, twoHoles)),
	futureRealOdds: promiseThrottle.add(odds.bind(this, twoHoles, dead))
	});
	}

	const results = [];
	const best = {edge: 0};
	for (let i = 0; i < options.length; ++i) {
	const option = options[i];

	const assumedEV = calcEv2((await option.futureAssumedOdds)[0]);
	const realEV = calcEv2((await option.futureRealOdds)[0]);
	const edge = Math.round(10000*Math.abs(assumedEV - realEV))/10000;

	results.push({
	index1: option.index1,
	index2: option.index2,
	twoHoles: option.twoHoles,
	assumedEV,
	realEV,
	edge
	});

	if (edge > best.edge) {
	best.index1 = option.index1,
	best.index2 = option.index2,
	best.edge = edge;
	best.twoHoles = option.twoHoles;
	best.assumedEV = assumedEV;
	best.realEV = realEV;
	}
	}

	// Print
	console.log(holes);
	results.forEach(({twoHoles, assumedEV, realEV, edge}) => {
	console.log(`${stringifyHole(twoHoles[0])} vs ${stringifyHole(twoHoles[1])}: assumed: ${assumedEV}, actual: ${realEV}}, edge: ${edge}`);
	});
	console.log('------------');
	console.log(`${stringifyHole(best.twoHoles[0])} vs ${stringifyHole(best.twoHoles[1])} has best edge: ${best.edge}`);

	return best;
	};

	////////////////////////////////////////

	const players = 10;
	const holeCards = 2;

	const deck = Combinatorics.cartesianProduct(['2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A'], ['s', 'c', 'd', 'h']).map(x => x.join(''));

	(async () => {
	try {
	await sample(deck, holeCards, players);
	} catch (e) {}
	})();
Hand 1	Hand 2	PokerStars	Real	Edge
J♠Q♣	A♣9♦	42.65%	39.74%	2.92%
J♠Q♣	K♠9♣	42.13%	43.59%	1.46%
A♣9♦	K♠9♣	74.42%	80.20%	5.78%
J♠Q♣	T♠7♦	67.63%	62.05%	5.58%
A♣9♦	T♠7♦	61.56%	57.88%	3.68%
K♠9♣	T♠7♦	62.61%	54.35%	8.26%
J♠Q♣	3♥Q♠	73.32%	70.02%	3.30%
A♣9♦	3♥Q♠	63.48%	64.03%	0.55%
K♠9♣	3♥Q♠	64.81%	61.10%	3.70%
T♠7♦	3♥Q♠	42.74%	48.73%	5.99%
J♠Q♣	K♦4♣	44.48%	43.97%	0.51%
A♣9♦	K♦4♣	63.83%	64.90%	1.07%
K♠9♣	K♦4♣	69.93%	65.45%	4.48%
T♠7♦	K♦4♣	42.55%	48.56%	6.01%
3♥Q♠	K♦4♣	36.12%	36.52%	0.40%
	╔═══════════╦════════════╦════════╦════════╗
	║ Combo ║ PokerStars ║ Real ║ Edge ║
	╠═══════════╬════════════╬════════╬════════╣
	║ J♠Q♣\|A♣9♦ ║ 42.65% ║ 39.74% ║ 2.92% ║
	║ J♠Q♣\|K♠9♣ ║ 42.13% ║ 43.59% ║ 1.46% ║
	║ A♣9♦\|K♠9♣ ║ 74.42% ║ 80.20% ║ 5.78% ║
	║ J♠Q♣\|T♠7♦ ║ 67.63% ║ 62.05% ║ 5.58% ║
	║ A♣9♦\|T♠7♦ ║ 61.56% ║ 57.88% ║ 3.68% ║
	║ K♠9♣\|T♠7♦ ║ 62.61% ║ 54.35% ║ 8.26% ║ ← information edge
	║ J♠Q♣\|3♥Q♠ ║ 73.32% ║ 70.02% ║ 3.30% ║
	║ A♣9♦\|3♥Q♠ ║ 63.48% ║ 64.03% ║ 0.55% ║
	║ K♠9♣\|3♥Q♠ ║ 64.81% ║ 61.10% ║ 3.70% ║
	║ T♠7♦\|3♥Q♠ ║ 42.74% ║ 48.73% ║ 5.99% ║
	║ J♠Q♣\|K♦4♣ ║ 44.48% ║ 43.97% ║ 0.51% ║
	║ A♣9♦\|K♦4♣ ║ 63.83% ║ 64.90% ║ 1.07% ║
	║ K♠9♣\|K♦4♣ ║ 69.93% ║ 65.45% ║ 4.48% ║
	║ T♠7♦\|K♦4♣ ║ 42.55% ║ 48.56% ║ 6.01% ║
	║ 3♥Q♠\|K♦4♣ ║ 36.12% ║ 36.52% ║ 0.40% ║
	╚═══════════╩════════════╩════════╩════════╝