Crate postflop_solver

An open-source postflop solver library.

Examples

See the examples directory.

Implementation details

• Algorithm: The solver uses the state-of-the-art Discounted CFR algorithm. Currently, the value of γ is set to 3.0 instead of the 2.0 recommended in the original paper. Also, the solver resets the cumulative strategy when the number of iterations is a power of 4.
• Performance: The solver engine is highly optimized for performance with maintainable code. The engine supports multithreading by default, and it takes full advantage of unsafe Rust in hot spots. The developer reviews the assembly output from the compiler and ensures that SIMD instructions are used as much as possible. Combined with the algorithm described above, the performance surpasses paid solvers such as PioSOLVER and GTO+.
• Isomorphism: The solver does not perform any abstraction. However, isomorphic chances (turn and river deals) are combined into one. For example, if the flop is monotone, the three non-dealt suits are isomorphic, allowing us to skip the calculation for two of the three suits.
• Precision: 32-bit floating-point numbers are used in most places. When calculating summations, temporary values use 64-bit floating-point numbers. There is also a compression option where each game node stores the values by 16-bit integers with a single 32-bit floating-point scaling factor.
• Bunching effect: At the time of writing, this is the only implementation that can handle the bunching effect. It supports up to four folded players (6-max game). The implementation correctly counts the number of card combinations and does not rely on heuristics such as manipulating the probability distribution of the deck. Note, however, that enabling the bunching effect increases the time complexity of the evaluation at the terminal nodes and slows down the computation significantly.

Crate features

• bincode: Uses bincode crate (2.0.0-rc.3) to serialize and deserialize the PostFlopGame struct. This feature is required to save and load the game tree. Enabled by default.
• custom-alloc: Uses custom memory allocator in solving process (only available in nightly Rust). It significantly reduces the number of calls of the default allocator, so it is recommended to use this feature when the default allocator is not so efficient. Note that this feature assumes that, at most, only one instance of PostFlopGame is available when solving in a program. Disabled by default.
• rayon: Uses rayon crate for parallelization. Enabled by default.
• zstd: Uses zstd crate to compress and decompress the game tree. This feature is required to save and load the game tree with compression. Disabled by default.

Structs

• ActionTree
  A struct representing an abstract game tree.
• BetSizeOptions
  Bet size options for the first bets and raises.
• BunchingData
  A configuration for computing the bunching effect.
• CardConfig
  A struct containing the card configuration.
• DonkSizeOptions
  Bet size options for the donk bets.
• MutexGuardLike
  Smart pointer like wrapper that is returned when MutexLike is “locked”.
• MutexLike
  Mutex-like wrapper, but it actually does not perform any locking.
• PostFlopGame
  A struct representing a postflop game.
• PostFlopNode
  A struct representing a node in a postflop game tree.
• Range
  A struct representing a player’s range.
• TreeConfig
  A struct containing the game tree configuration.

Enums

• Action
  Available actions of the postflop game.
• BetSize
  Bet size specification.
• BoardState
  An enum representing the board state.

Constants

• NOT_DEALT
  Constant representing that the card is not yet dealt.

Traits

• FileData
  A trait for data that can be saved into a file.
• Game
  The trait representing a game.
• GameNode
  The trait representing a node in game tree.

Functions

• card_from_chars
  Attempts to read the next card from a char iterator.
• card_from_str
  Attempts to convert a string into a card.
• card_to_string
  Attempts to convert a card into a string.
• compute_average
  Computes the average with given weights.
• compute_current_ev
  Computes the expected values of the current strategy of each player.
• compute_exploitability
  Computes the exploitability of the current strategy.
• compute_mes_ev
  Computes the expected values of the MES (Maximally Exploitative Strategy) of each player.
• finalize
  Finalizes the solving process.
• flop_from_str
  Attempts to convert an optionally space-separated string into a sorted flop array.
• hole_to_string
  Attempts to convert hole cards into a string.
• holes_to_strings
  Attempts to convert a list of hole cards into a list of strings.
• load_data_from_file
  Loads data from a file.
• load_data_from_std_read
  Loads data from a standard reader.
• save_data_into_std_write
  Saves data into a standard writer.
• save_data_to_file
  Saves data into a file.
• solve
  Performs Discounted CFR algorithm until the given number of iterations or exploitability is satisfied.
• solve_step
  Proceeds Discounted CFR algorithm for one iteration.

Type Aliases

• Card
  A type representing a card, defined as an alias of u8.