RS-Poker

https://docs.rs/rs_poker/latest/
Admin
RS-Poker is a Rust library for poker that provides hand iteration, ranking, range parsing, Monte...
Tokens:224,546
Snippets:2,198
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### GameStartPayload Struct

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/action/struct.GameStartPayload.html

Defines the structure for game start parameters.

```APIDOC
## Struct GameStartPayload

rs_poker::arena::action

### Summary

The game has started.

### Fields

* `ante`: f32 - The ante amount for the game.
* `small_blind`: f32 - The small blind amount for the game.
* `big_blind`: f32 - The big blind amount for the game.

### Example

```rust
{
  "ante": 10.0,
  "small_blind": 5.0,
  "big_blind": 10.0
}
```
```

--------------------------------

### Start New Game Round

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/simulation.rs.html

Initializes the game by recording starting parameters like ante, small blind, and big blind. It also records the starting stack for each player.

```rust
fn start(&mut self) {
        let span = trace_span!("start");
        let _enter = span.enter();

        // Add an action to record the ante, sb and bb
        // This should allow recreating starting game state
        // together with PlayerSit actions.
        self.record_action(Action::GameStart(GameStartPayload {
            ante: self.game_state.ante,
            small_blind: self.game_state.small_blind,
            big_blind: self.game_state.big_blind,
        }));

        while self.game_state.current_round_num_active_players() > 0 {
            let idx = self.game_state.to_act_idx();

            // Add an action that records starting stack for each player

```

--------------------------------

### Parse a single starting hand with specified suited cards

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Parse hands where suits are not specified but are intended to be suited, using notations like "AKs". This example verifies that the parsed hands are indeed suited and match the specified ranks.

```rust
use rs_poker::core::Value;
use rs_poker::holdem::RangeParser;

let hands = RangeParser::parse_one("AKs").unwrap();
assert!(hands.len() == 4);
for hand in hands {
    assert!(hand[0].suit == hand[1].suit);
    assert_eq!(Value::Ace, hand[0].value);
    assert_eq!(Value::King, hand[1].value);
}
```

--------------------------------

### ActivePlayerBitSetIter Examples

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.ActivePlayerBitSetIter.html

Demonstrates how to use ActivePlayerBitSetIter by iterating over active player indices in a PlayerBitSet.

```APIDOC
```rust
use rs_poker::core::PlayerBitSet;

let mut set = PlayerBitSet::default();

set.enable(0);
set.enable(4);
set.enable(2);

let mut iter = set.ones();

assert_eq!(iter.next(), Some(0));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(4));
assert_eq!(iter.next(), None);
```
```

--------------------------------

### CFRState::new

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/state.rs.html

Creates a new CFRState instance with a given starting game state.

```APIDOC
## CFRState::new

### Description
Creates a new CFRState instance with a given starting game state.

### Method
`pub fn new(game_state: GameState) -> Self`

### Parameters
- `game_state` (GameState) - The initial state of the game.

### Returns
- `Self` - A new CFRState instance.
```

--------------------------------

### Create a Default Starting Hand

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Use this function to create a specific starting hand by providing two card values and their suitedness. This is useful for defining exact hands like Ace-King suited.

```rust
pub fn default(value_one: Value, value_two: Value, suited: Suitedness) -> Self {
        Self::Def(Default {
            value_one,
            value_two,
            suited,
        })
    }
```

--------------------------------

### starting_game_state

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/competition/struct.SingleTableTournamentBuilder.html

Sets the starting game state for the tournament.

```APIDOC
## starting_game_state

### Description
Sets the starting game state for the tournament.

### Method
`starting_game_state`

### Parameters
- **starting_game_state** (GameState) - Required - The initial game state.

### Returns
- **Self** - The builder instance with the starting game state set.
```

--------------------------------

### Generate Hold'em Starting Hands

Source: https://docs.rs/rs_poker/latest/index.html

Generates all possible starting hands for Texas Hold'em given specific card values and suitedness. Requires importing `Value`, `StartingHand`, and `Suitedness` from the `rs_poker` crate.

```rust
use rs_poker::core::Value;
use rs_poker::holdem::{StartingHand, Suitedness};

let hands = StartingHand::default(Value::Ace, Value::Ace, Suitedness::OffSuit).possible_hands();
assert_eq!(6, hands.len());
```

--------------------------------

### Create a Starting Hand with a Range

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Use this function to create a starting hand where the second card can be any value within a specified range. This is useful for representing hands like Ace-X, where X can be any card from 2 to King.

```rust
pub fn single_range(value_one: Value, start: Value, end: Value, suited: Suitedness) -> Self {
        Self::SingleCardRange(SingleCardRange {
            value_one,
            start,
            end,
            suited,
        })
    }
```

--------------------------------

### Parse a single starting hand with specified offsuit cards

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Parse hands where suits are not specified and are intended to be offsuit, using notations like "AKo". This example checks that the parsed hands have different suits and match the specified ranks.

```rust
use rs_poker::core::Value;
use rs_poker::holdem::RangeParser;

let hands = RangeParser::parse_one("AKo").unwrap();

for hand in hands {
    assert!(hand[0].suit != hand[1].suit);
    assert_eq!(Value::Ace, hand[0].value);
    assert_eq!(Value::King, hand[1].value);
}
```

--------------------------------

### Get Current Player's Starting Stack

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Retrieves the initial stack size for the player whose turn it is to act at the beginning of the game.

```rust
pub fn current_player_starting_stack(&self) -> f32
```

--------------------------------

### Initialize CFRState

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/cfr/struct.CFRState.html

Demonstrates how to create a new CFRState instance with an initial game state. This is the starting point for CFR calculations.

```rust
use rs_poker::arena::GameState;
use rs_poker::arena::cfr::CFRState;

let game_state = GameState::new_starting(vec![100.0; 2], 10.0, 5.0, 0.0, 0);
let cfr_state = CFRState::new(game_state);
```

--------------------------------

### Initialize Starting GameState

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Creates a GameState for the beginning of a game, setting up initial stacks and blind/ante values. The dealer index is also specified.

```rust
pub fn new_starting( stacks: Vec<f32>, big_blind: f32, small_blind: f32, ante: f32, dealer_idx: usize, ) -> Self
```

--------------------------------

### FlatDeck push method example

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_deck.rs.html

Demonstrates how to add a card to the FlatDeck. This method does not check for duplicates and simply appends the card to the end of the deck.

```rust
use rs_poker::core::{Card, Deck, FlatDeck, Suit, Value};

let mut deck: FlatDeck = Deck::new().into();
let card = Card::new(Value::Ace, Suit::Club);
deck.push(card);

assert_eq!(1, deck.len());
assert_eq!(card, deck.deal().unwrap());

```

--------------------------------

### RoundData::new_with_bets Constructor Example

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/game_state.rs.html

Demonstrates creating a `RoundData` instance with pre-existing bet information, useful for simulating mid-round scenarios.

```rust
/// Create a new round data with the given bets.
/// This is useful for creating a new round data that represents
/// a round that is halfway through. For example, if we're trying
/// to simulate a choosing to call an all in on the river.
///
/// # Arguments
///
/// * `num_players` - The number of players in the game.
/// * `min_raise` - The minimum raise allowed in the round.
/// * `active` - The players that are active in the round.
/// * `to_act` - The index of the player that is next to act.
/// * `player_bet` - The amount each player has bet so far.
///
/// # Returns
///
/// A new round data with the given bets, the bets are
/// used to assume other values of the round.
///
/// # Example
///
/// ```
/// use rs_poker::arena::game_state::RoundData;
/// use rs_poker::core::PlayerBitSet;
///
/// let num_players = 3;
/// let min_raise = 10.0;
/// let active = PlayerBitSet::new(num_players);
///
/// let player_bet = vec![0.0, 10.0, 20.0];
/// let to_act = 0;
///
/// let round_data = RoundData::new_with_bets(min_raise, active, to_act, player_bet);
///
/// assert_eq!(round_data.bet, 20.0);
///
/// assert_eq!(round_data.total_bet_count, 2);
///
/// assert_eq!(round_data.total_raise_count, 2);
/// ```
pub fn new_with_bets(
    min_raise: f32,
    active: PlayerBitSet,
    to_act: usize,
    player_bet: Vec<f32>,
) -> Self {
    let bet: f32 = player_bet.iter().fold(0.0, |acc, &x| acc.max(x));

```

--------------------------------

### CardBitSet::default

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.CardBitSet.html

Creates a new CardBitSet with all cards initialized. This is useful for starting with a full set of cards.

```APIDOC
## fn default() -> Self

### Description
Create a new bitset with all the cards in it

### Returns
A new `CardBitSet` instance with all cards.

### Example
```rust
use rs_poker::core::CardBitSet;

let cards = CardBitSet::default();

assert_eq!(52, cards.count());
assert!(!cards.is_empty());
```
```

--------------------------------

### StartingHand::all

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Generates and returns a vector containing all possible unique starting hands in Texas Hold'em, considering all card combinations and suitedness.

```APIDOC
/// Create every possible unique StartingHand.
pub fn all() -> Vec<Self>
```

--------------------------------

### Create Default Starting Hand

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/enum.StartingHand.html

Use this function to create a StartingHand when both cards are specified exactly, including their suitedness.

```rust
pub fn default(value_one: Value, value_two: Value, suited: Suitedness) -> Self
```

--------------------------------

### Setting up and running a Hold'em Competition

Source: https://docs.rs/rs_poker/latest/src/rs_poker/lib.rs.html

This example demonstrates how to set up a Hold'em competition with multiple agents and run a specified number of simulations. It requires defining agent generators, initial player stacks, and game state parameters.

```rust
use rs_poker::arena::
    AgentGenerator,
    CloneGameStateGenerator, GameState,
    agent::{CallingAgentGenerator, RandomAgentGenerator},
    competition::{HoldemCompetition, StandardSimulationIterator},
};
let agent_gens: Vec<Box<dyn AgentGenerator>> = vec![
    Box::<RandomAgentGenerator>::default(),
    Box::<CallingAgentGenerator>::default(),
    Box::<CallingAgentGenerator>::default(),
];
let stacks = vec![100.0; 3];
let game_state = GameState::new_starting(stacks, 10.0, 5.0, 0.0, 0);
let sim_gen = StandardSimulationIterator::new(
    agent_gens,
    vec![], // no historians
    CloneGameStateGenerator::new(game_state),
);
let mut competition = HoldemCompetition::new(sim_gen);
let _first_results = competition.run(100).unwrap();
```

--------------------------------

### Get Current Player's Starting Stack Size

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/game_state.rs.html

Returns the initial stack size of the player whose turn it is to act.

```rust
pub fn current_player_starting_stack(&self) -> f32 {
        *self.starting_stacks.get(self.to_act_idx()).unwrap_or(&0.0)
    }
```

--------------------------------

### Create a New Empty Deck

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.Deck.html

Initializes a new, empty Deck instance. Useful for starting with a clean slate before adding specific cards.

```rust
use rs_poker::core::Deck;

let deck = Deck::new();

assert!(deck.is_empty());
assert_eq!(0, deck.len());
```

--------------------------------

### Expand Starting Hand to Concrete Hands

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/enum.StartingHand.html

Call this method on a StartingHand instance to get a vector of all the specific FlatHand combinations it represents.

```rust
pub fn possible_hands(&self) -> Vec<FlatHand>
```

--------------------------------

### Parse a comma-separated list of starting hands

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Use `parse_many` to parse a string containing multiple starting hands separated by commas, such as "KK+,A2s+". This example demonstrates parsing a complex range and checking the total number of hands generated.

```rust
use rs_poker::holdem::RangeParser;

let hand = RangeParser::parse_many("KK+,A2s+").unwrap();
assert_eq!(60, hand.len());

// Filters out duplicates.
assert_eq!(RangeParser::parse_many("AK-87s,A2s+").unwrap().len(), 72)
```

--------------------------------

### Initialize and Push Card to FlatDeck

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_deck.rs.html

Demonstrates initializing a FlatDeck from a new Deck and pushing a single card. Asserts that the pushed card is at the first index.

```rust
let mut fd: FlatDeck = Deck::new().into();

        let c = Card {
            value: Value::Nine,
            suit: Suit::Heart,
        };
        fd.push(c);
        assert_eq!(c, fd[0]);
```

--------------------------------

### Set Starting Game State

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/competition/struct.SingleTableTournamentBuilder.html

Sets the initial state of the game for the tournament. This allows for pre-defined game conditions.

```rust
pub fn starting_game_state(self, starting_game_state: GameState) -> Self
```

--------------------------------

### Initialize and Push Multiple Cards to FlatDeck

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_deck.rs.html

Shows how to initialize a FlatDeck and push multiple cards sequentially. Verifies that each card is correctly placed at its respective index.

```rust
let mut fd: FlatDeck = Deck::new().into();
        let c = Card {
            value: Value::Nine,
            suit: Suit::Heart,
        };
        let c2 = Card {
            value: Value::Ten,
            suit: Suit::Heart,
        };
        fd.push(c);
        fd.push(c2);
        assert_eq!(c, fd[0]);
        assert_eq!(c2, fd[1]);
```

--------------------------------

### Get All Possible Values

Source: https://docs.rs/rs_poker/latest/rs_poker/core/enum.Value.html

Returns an array containing all possible Value enum variants. This is useful for iterating through all card ranks, for example, when creating a new deck.

```rust
pub fn values() -> [Self; 13]
```

--------------------------------

### GameState::new_starting

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Constructs a new GameState for the beginning of a game, initializing with player stacks and betting information.

```APIDOC
## GameState::new_starting

### Description
Constructs a new GameState for the beginning of a game, initializing with player stacks and betting information.

### Signature
```rust
pub fn new_starting( stacks: Vec<f32>, big_blind: f32, small_blind: f32, ante: f32, dealer_idx: usize, ) -> Self
```

### Parameters
* `stacks`: A vector representing the initial stack size for each player.
* `big_blind`: The size of the big blind.
* `small_blind`: The size of the small blind.
* `ante`: The ante amount.
* `dealer_idx`: The index of the player who is the dealer.
```

--------------------------------

### Get all possible card values

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/card.rs.html

Provides a constant array of all possible `Value` enums. This is useful for iterating through all values when creating a new deck or generating possible starting hands.

```rust
pub const fn values() -> [Self; 13] {
    VALUES
}
```

--------------------------------

### Push Game State to Store

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/state_store.rs.html

Adds a new game state to the StateStore and verifies its presence. The starting game state of the pushed state is checked against the original.

```rust
#[test]
    fn test_push() {
        let mut state_store = StateStore::new();
        let game_state = GameState::new_starting(vec![100.0; 3], 10.0, 5.0, 0.0, 0);
        let (state, _traversal) = state_store.new_state(game_state.clone(), 0);
        assert_eq!(
            state_store.len(),
            1,
            "State store should have one state after push"
        );
        assert_eq!(
            state.starting_game_state(),
            game_state,
            "State should match the game state"
        );
    }
```

--------------------------------

### Initialize New StateStore

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/state_store.rs.html

Creates a new, empty StateStore. Asserts that the initial length is zero.

```rust
#[test]
    fn test_new() {
        let store = StateStore::new();
        assert_eq!(store.len(), 0, "New state store should have no states");
    }
```

--------------------------------

### Parse a single starting hand with specified suits

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Use `parse_one` to convert a string like "AhKh" into a vector of `FlatHand` objects. This example demonstrates parsing a hand with explicitly defined suits.

```rust
use rs_poker::holdem::RangeParser;

let hand = RangeParser::parse_one("AhKh").unwrap();
assert_eq!(1, hand.len());
```

--------------------------------

### Parse starting hands with the '+' modifier for connectors

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Use the '+' modifier with connectors (e.g., "T9o+") to parse all offsuit connectors where both cards are above the specified ranks. This example checks that the parsed hands are connectors and meet the rank criteria.

```rust
use rs_poker::core::Value;
use rs_poker::holdem::RangeParser;

let hands = RangeParser::parse_one("T9o+").unwrap();

for hand in hands {
    assert_eq!(hand[0].value, Value::from_u8(hand[1].value as u8 + 1));
    assert!(hand[0].suit != hand[1].suit);
}
```

--------------------------------

### GameStartPayload Struct Definition

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/action/struct.GameStartPayload.html

Defines the structure for game start payload, containing ante, small blind, and big blind amounts.

```rust
pub struct GameStartPayload {
    pub ante: f32,
    pub small_blind: f32,
    pub big_blind: f32,
}
```

--------------------------------

### Parse starting hands with the '+' modifier for pairs

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Use the '+' modifier with pairs (e.g., "TT+") to parse all pairs equal to or above the specified rank. This example validates that the parsed hands are pairs and meet the minimum rank requirement.

```rust
use rs_poker::core::Value;
use rs_poker::holdem::RangeParser;

let hands = RangeParser::parse_one("TT+").unwrap();

for hand in hands {
    assert!(hand[0].value == hand[1].value);
    assert!(hand[0].value >= Value::Ten);
    assert!(hand[1].value >= Value::Ten);
}
```

--------------------------------

### StartingHand Methods

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/enum.StartingHand.html

Provides methods for creating and manipulating StartingHand instances.

```APIDOC
## impl StartingHand

### `fn default(value_one: Value, value_two: Value, suited: Suitedness) -> Self`
Create a default starting hand with two `Value`’s and a `Suitedness`.

### `fn single_range(value_one: Value, start: Value, end: Value, suited: Suitedness) -> Self`
Create a new StartingHand with the second card being a range.

### `fn all() -> Vec<Self>`
Create every possible unique StartingHand.

### `fn possible_hands(&self) -> Vec<FlatHand>`
From a `StartingHand` specify all the hands this could represent.
```

--------------------------------

### Create a new empty VecHistorian

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/historian/struct.VecHistorian.html

Creates a new, empty VecHistorian. This is the simplest way to start recording actions from scratch.

```rust
pub fn new() -> Self
```

--------------------------------

### CFRAgent Initialization with Forced Action

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/agent.rs.html

Creates a new CFRAgent that will initially play a specific action. Useful for starting exploration from a predetermined move.

```rust
fn new_with_forced_action(
        state_store: StateStore,
        cfr_state: CFRState,
        traversal_state: TraversalState,
        gamestate_iterator_gen: I,
        forced_action: AgentAction,
    ) -> Self {
        let action_generator = T::new(cfr_state.clone(), traversal_state.clone());
        CFRAgent {
            state_store,
            cfr_state,
            traversal_state,
            action_generator,
            gamestate_iterator_gen,
            force_recompute: false,
            forced_action: Some(forced_action),
        }
    }
```

--------------------------------

### Parse starting hands with the '+' modifier for non-paired, non-connector hands

Source: https://docs.rs/rs_poker/latest/rs_poker/holdem/struct.RangeParser.html

Use the '+' modifier for hands that are not pairs or connectors (e.g., "A9s+") to parse all suited hands where the second card is greater than or equal to the specified rank and less than the first card. This example validates the parsed suited hands based on these criteria.

```rust
use rs_poker::core::Value;
use rs_poker::holdem::RangeParser;
let hands = RangeParser::parse_one("A9s+").unwrap();
for hand in hands {
    assert!(hand[0].value > hand[1].value);
    assert!(hand[1].value >= Value::Nine);
    assert!(hand[0].suit == hand[1].suit);
}
```

--------------------------------

### Initialize StateStore

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/state_store.rs.html

Creates a new, empty StateStore. This is the entry point for managing game states during CFR solving.

```rust
pub fn new() -> Self {
        StateStore {
            inner: Arc::new(RwLock::new(StateStoreInternal {
                cfr_states: Vec::new(),
                traversal_states: Vec::new(),
            })),
        }
    }
```

--------------------------------

### HoldemSimulationBuilder with Custom Agents

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/sim_builder/struct.HoldemSimulationBuilder.html

Illustrates building a Holdem simulation with a custom set of agents and a specified game state. This allows for simulations with non-default agent behaviors.

```rust
use rand::{SeedableRng, rngs::StdRng};
use rs_poker::arena::{Agent, agent::FoldingAgent};
use rs_poker::arena::{GameState, HoldemSimulationBuilder};

let game_state = GameState::new_starting(vec![100.0; 5], 2.0, 1.0, 0.0, 3);
let agents: Vec<Box<dyn Agent>> = (0..5)
    .map(|_| Box::<FoldingAgent>::default() as Box<dyn Agent>)
    .collect();
let sim = HoldemSimulationBuilder::default()
    .game_state(game_state)
    .agents(agents)
    .build();
```

--------------------------------

### Hold'em Starting Hand Struct

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Represents a two-card starting hand in Texas Hold'em, specifying two card values and their suitedness. Used to generate all possible actual starting hands.

```rust
pub struct Default {
    /// The first value.
    value_one: Value,
    /// The second value.
    value_two: Value,
    /// should we only consider possible starting hands of the same suit?
    suited: Suitedness,
}
```

--------------------------------

### Get Type ID

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/agent/struct.RandomPotControlAgent.html

Gets the `TypeId` of the implementing type. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId>
```

--------------------------------

### Build and Run Hold'em Simulation

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/agent/random.rs.html

Sets up a Hold'em simulation with a specified game state and agents, then runs the simulation. Asserts that betting occurred and validates the final game state.

```rust
let mut sim = HoldemSimulationBuilder::default()
            .game_state(game_state)
            .agents(agents)
            .deck(deck)
            .build()
            .unwrap();

sim.run(&mut rng);

let min_stack = sim
            .game_state
            .stacks
            .clone()
            .into_iter()
            .reduce(f32::min)
            .unwrap();
        let max_stack = sim
            .game_state
            .stacks
            .clone()
            .into_iter()
            .reduce(f32::max)
            .unwrap();

        assert_ne!(min_stack, max_stack, "There should have been some betting.");

        assert_valid_round_data(&sim.game_state.round_data);
        assert_valid_game_state(&sim.game_state);
```

--------------------------------

### Create a new Card

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.Card.html

Demonstrates how to create a new Card instance by providing its Value and Suit. It also shows how to assert the correctness of the created card's fields.

```rust
use rs_poker::core::{Card, Suit, Value};
let c = Card::new(Value::Ace, Suit::Spade);
assert_eq!(Value::Ace, c.value);
assert_eq!(Suit::Spade, c.suit);
```

--------------------------------

### Test Aces Starting Hand

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Asserts that an Ace-Ace offsuit starting hand correctly expands to 6 possible game hands. This test verifies the `possible_hands` expansion for a pair.

```rust
let sh = Default {
            value_one: Value::Ace,
            value_two: Value::Ace,
            suited: Suitedness::OffSuit,
        };
        assert!(6 == sh.possible_hands().len());
```

--------------------------------

### Test Total Starting Hand Count

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Verifies that the sum of all possible hands generated from all unique starting hands equals 1326. This test ensures the completeness of the `StartingHand::all()` generation.

```rust
let num_to_test: usize = StartingHand::all()
            .iter()
            .map(|h| h.possible_hands().len())
            .sum();
        assert!(1326 == num_to_test);
```

--------------------------------

### Create and Assert FlatHand

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_hand.rs.html

Demonstrates creating a FlatHand using default and push methods, then asserting its content.

```rust
let mut h = FlatHand::default();
h.push(Card {
            value: Value::Four,
            suit: Suit::Spade,
        });
        // Make sure the card is there
        assert_eq!(
            Card {
                value: Value::Four,
                suit: Suit::Spade,
            },
            h[0]
        );
```

--------------------------------

### StateStore::new

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/cfr/struct.StateStore.html

Creates a new instance of StateStore.

```APIDOC
## StateStore::new

### Description
Creates a new, empty `StateStore`.

### Method
`pub fn new() -> Self`

### Returns
A new `StateStore` instance.
```

--------------------------------

### Test Unsuited Connector Starting Hand

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Asserts that an Ace-King offsuit starting hand correctly expands to 12 possible game hands. This test verifies the `possible_hands` expansion for offsuit connectors.

```rust
let sh = Default {
            value_one: Value::Ace,
            value_two: Value::King,
            suited: Suitedness::OffSuit,
        };
        assert!(12 == sh.possible_hands().len());
```

--------------------------------

### Test Suited Connector Starting Hand

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Asserts that an Ace-King suited starting hand correctly expands to 4 possible game hands. This test verifies the `possible_hands` expansion for suited connectors.

```rust
let sh = Default {
            value_one: Value::Ace,
            value_two: Value::King,
            suited: Suitedness::Suited,
        };
        assert!(4 == sh.possible_hands().len());
```

--------------------------------

### CFRState::starting_game_state

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/state.rs.html

Retrieves a clone of the initial game state associated with this CFRState.

```APIDOC
## CFRState::starting_game_state

### Description
Retrieves a clone of the initial game state associated with this CFRState.

### Method
`pub fn starting_game_state(&self) -> GameState`

### Returns
- `GameState` - A clone of the starting game state.
```

--------------------------------

### HoldemSimulationBuilder: build() method

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/sim_builder.rs.html

Builds a new `HoldemSimulation`. It requires a `game_state` to be set, otherwise it returns a `HoldemSimulationError::NeedGameState`.

```rust
pub fn build(self) -> Result<HoldemSimulation, HoldemSimulationError> {
    let game_state = self
        .game_state
        .ok_or(HoldemSimulationError::NeedGameState)?;

    let agents = self
```

--------------------------------

### Any::type_id

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/agent/struct.VecReplayAgent.html

Gets the `TypeId` of `self`.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
```

--------------------------------

### GameState::type_id

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Gets the `TypeId` of the GameState.

```APIDOC
## GameState::type_id

### Description
Gets the `TypeId` of the GameState.

### Signature
```rust
fn type_id(&self) -> TypeId
```

### Returns
The `TypeId` of the `GameState`.
```

--------------------------------

### Create and Manipulate a Deck

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.Deck.html

Demonstrates the creation of a new deck, adding cards, checking for their existence, removing them, and verifying the deck's size and emptiness. This snippet covers common deck operations.

```rust
use rs_poker::core::{Card, Deck, Suit, Value};

// create a new deck
let mut deck = Deck::new();

// add some cards to the deck
deck.insert(Card::new(Value::Ace, Suit::Club));
deck.insert(Card::new(Value::King, Suit::Diamond));
deck.insert(Card::new(Value::Queen, Suit::Heart));

// check if a card is in the deck
let card = Card::new(Value::Ace, Suit::Club);
assert!(deck.contains(&card));

// remove a card from the deck
assert!(deck.remove(&card));
assert!(!deck.contains(&card));

// get the number of cards in the deck
assert_eq!(deck.len(), 2);

// check if the deck is empty
assert!(!deck.is_empty());

// get an iterator from the deck
for card in deck.iter() {
    println!("{:?}", card);
}
```

--------------------------------

### SingleTableTournamentBuilder::starting_game_state Method

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/competition/tournament.rs.html

Sets the initial state of the game for the tournament. This includes initial player stacks, blinds, and other relevant game parameters.

```rust
pub fn starting_game_state(mut self, starting_game_state: GameState) -> Self {
    self.starting_game_state = Some(starting_game_state);
    self
}
```

--------------------------------

### Single Card Range Struct

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/starting_hand.rs.html

Represents a starting hand where one card has a fixed value, and the other card's value falls within a specified inclusive range (`start` to `end`). It also includes a `suited` property to filter by suit combinations.

```rust
pub struct SingleCardRange {
    /// First value; this one will not change.
    value_one: Value,
    /// Inclusive start range
    start: Value,
    /// Inclusive end range
    end: Value,
    /// What Suits can this have.
    suited: Suitedness,
}
```

--------------------------------

### Run Poker Simulations with HoldemCompetition

Source: https://docs.rs/rs_poker/latest/index.html

Sets up and runs a series of poker simulations using agents and a game state generator. Requires importing necessary components from the arena module. The number of simulations to run is specified in the `run` method.

```rust
use rs_poker::arena::
    AgentGenerator,
    CloneGameStateGenerator,
    GameState,
    agent::{CallingAgentGenerator, RandomAgentGenerator},
    competition::{HoldemCompetition, StandardSimulationIterator},
};
let agent_gens: Vec<Box<dyn AgentGenerator>> = vec![
    Box::<RandomAgentGenerator>::default(),
    Box::<CallingAgentGenerator>::default(),
    Box::<CallingAgentGenerator>::default(),
];
let stacks = vec![100.0; 3];
let game_state = GameState::new_starting(stacks, 10.0, 5.0, 0.0, 0);
let sim_gen = StandardSimulationIterator::new(
    agent_gens,
    vec![], // no historians
    CloneGameStateGenerator::new(game_state),
);
let mut competition = HoldemCompetition::new(sim_gen);
let _first_results = competition.run(100).unwrap();
```

--------------------------------

### Get FlatHand Length

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_hand.rs.html

Returns the current number of cards in the hand.

```rust
pub fn len(&self) -> usize {
        self.0.len()
    }
```

--------------------------------

### HoldemSimulationBuilder Build Method

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/sim_builder/struct.HoldemSimulationBuilder.html

Builds the HoldemSimulation after all configurations are set.

```APIDOC
## `build(self) -> Result<HoldemSimulation, HoldemSimulationError>`

Given the fields already specified build any that are not specified and create a new HoldemSimulation.

@returns HoldemSimulationError if no game_state was given.
```

--------------------------------

### GameState::current_round_num_active_players

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Gets the number of active players in the current round.

```APIDOC
## GameState::current_round_num_active_players

### Description
Gets the number of active players in the current round.

### Signature
```rust
pub fn current_round_num_active_players(&self) -> usize
```

### Returns
The number of active players in the current round.
```

--------------------------------

### take

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.CloneGameStateGenerator.html

Creates an iterator that yields the first `n` elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- **n** (usize) - The maximum number of elements to yield.
```

--------------------------------

### GameState::to_act_idx

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Gets the index of the player whose turn it is to act.

```APIDOC
## GameState::to_act_idx

### Description
Gets the index of the player whose turn it is to act.

### Signature
```rust
pub fn to_act_idx(&self) -> usize
```

### Returns
The index of the player to act.
```

--------------------------------

### Simulate Game with Predefined Agent Actions

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/agent/replay.rs.html

Sets up a Hold'em simulation with multiple agents, each having a predefined sequence of actions. Useful for testing game logic with specific agent behaviors.

```rust
let agent_one = Box::<VecReplayAgent>::new(VecReplayAgent::new(vec![\
            AgentAction::Bet(bb),\
            AgentAction::Bet(bb),\
        ]));\
        let agent_two = Box::<VecReplayAgent>::new(VecReplayAgent::new(vec![\
            AgentAction::Bet(bb),\
            AgentAction::Bet(bb),\
        ]));\
        let agent_three = Box::<VecReplayAgent>::new(VecReplayAgent::new(vec![AgentAction::Fold]));\
\
        let stacks = vec![bb + 5.906776e-3, bb + 5.906776e-39, bb];\
        let game_state = GameState::new_starting(stacks, bb, sb, 0.0, 0);\
        let agents: Vec<Box<dyn Agent>> = vec![agent_one, agent_two, agent_three];\
        let mut rng = StdRng::seed_from_u64(421);\
\
        let mut sim: HoldemSimulation = HoldemSimulationBuilder::default()\
            .game_state(game_state)\
            .agents(agents)\
            .build()\
            .unwrap();\
        sim.run(&mut rng);\
\
        assert_valid_round_data(&sim.game_state.round_data);\
        assert_valid_game_state(&sim.game_state);
```

--------------------------------

### Get Player Index

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/cfr/struct.TraversalState.html

Returns the index of the current player in the TraversalState.

```rust
pub fn player_idx(&self) -> usize
```

--------------------------------

### HoldemSimulationBuilder Default Configuration

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/sim_builder/struct.HoldemSimulationBuilder.html

Demonstrates the default usage of HoldemSimulationBuilder to create a simulation with a specified game state. The simulation will use default folding agents if none are provided.

```rust
use rs_poker::arena::{GameState, HoldemSimulationBuilder};

let game_state = GameState::new_starting(vec![100.0; 5], 2.0, 1.0, 0.0, 3);
let sim = HoldemSimulationBuilder::default()
    .game_state(game_state)
    .build()
    .unwrap();
```

--------------------------------

### Get Node Index

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/cfr/struct.TraversalState.html

Returns the index of the current node in the TraversalState.

```rust
pub fn node_idx(&self) -> usize
```

--------------------------------

### Agent::act

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/agent/struct.SliceReplayAgent.html

This method is called by the game to get the action from the agent.

```APIDOC
## `act`

### Description
This is the method that will be called by the game to get the action.

### Signature
```rust
fn act(self: &mut SliceReplayAgent<'a>, _id: u128, _game_state: &GameState) -> AgentAction
```

### Parameters
* `_id`: The identifier of the agent.
* `_game_state`: The current game state.
```

--------------------------------

### From Implementations

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_deck.rs.html

Provides ways to create a FlatDeck from other types.

```APIDOC
## From<Vec<Card>>

### Description
Creates a `FlatDeck` from a vector of `Card`s.

### Method
`impl From<Vec<Card>> for FlatDeck`

### Parameters
- `value` (Vec<Card>): The vector of cards to convert into a `FlatDeck`.

### Returns
- `FlatDeck`: A new `FlatDeck` containing the provided cards.
```

```APIDOC
## From<Deck>

### Description
Converts a `Deck` into a `FlatDeck`. The cards are sorted to ensure deterministic output.

### Method
`impl From<Deck> for FlatDeck`

### Parameters
- `value` (Deck): The `Deck` to convert.

### Returns
- `FlatDeck`: A new `FlatDeck` containing the cards from the `Deck`.
```

--------------------------------

### RoundData::new Constructor

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/game_state.rs.html

Initializes a new `RoundData` instance for the start of a round.

```rust
impl RoundData {
    pub fn new(num_players: usize, min_raise: f32, active: PlayerBitSet, to_act: usize) -> Self {
        RoundData {
            needs_action: active,
            starting_player_active: active,
            min_raise,
            bet: 0.0,
            player_bet: vec![0.0; num_players],
            total_bet_count: 0,
            total_raise_count: 0,
            to_act_idx: to_act,
        }
    }

```

--------------------------------

### GameState::current_player_starting_stack

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Retrieves the starting stack size of the player whose turn it is.

```APIDOC
## GameState::current_player_starting_stack

### Description
Retrieves the starting stack size of the player whose turn it is.

### Signature
```rust
pub fn current_player_starting_stack(&self) -> f32
```

### Returns
The starting stack size of the current player.
```

--------------------------------

### Initialize StatsStorage with Player Count

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/historian/stats_tracking.rs.html

Creates a new `StatsStorage` instance initialized with zero counts and totals for a specified number of players.

```rust
pub fn new_with_num_players(num_players: usize) -> Self {
        Self {
            actions_count: vec![0; num_players],

            vpip_count: vec![0; num_players],
            vpip_total: vec![0.0; num_players],

            vpip_ahead_count: vec![0; num_players],
            vpip_ahead_total: vec![0.0; num_players],

            raise_count: vec![0; num_players],

            raise_ahead_count: vec![0; num_players],
        }
    }
```

--------------------------------

### GameState::current_round_current_player_bet

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/game_state.rs.html

Gets the amount the current player has bet in the current round.

```APIDOC
## GameState::current_round_current_player_bet

### Description
Gets the amount the current player has bet in the current round.

### Method
```rust
pub fn current_round_current_player_bet(&self) -> f32
```

### Returns
- **f32** - The bet amount of the current player in this round.
```

--------------------------------

### Create and Manipulate PlayerBitSet

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.PlayerBitSet.html

Demonstrates creating a new PlayerBitSet, disabling a player, and checking the count of active players. Use this to manage player states.

```rust
use rs_poker::core::PlayerBitSet;
let mut active_players = PlayerBitSet::new(9);

// Player 4 folds
active_players.disable(4);
assert_eq!(8, active_players.count());
```

--------------------------------

### FlatHand::index (RangeFull)

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.FlatHand.html

Allows indexing into the hand to get a reference to all cards.

```APIDOC
## FlatHand::index (RangeFull)

### Description
Allow the index to get reference to every card.

### Method
`fn index(&self, range: RangeFull) -> &[Card]`
```

--------------------------------

### Deck::default

Source: https://docs.rs/rs_poker/latest/rs_poker/core/struct.Deck.html

Creates a default 52-card deck.

```APIDOC
## Deck::default

### Description
Creates the default 52 card deck.

### Method
`default() -> Self`

### Returns
- `Self`: A new `Deck` instance containing all 52 standard playing cards.

### Examples
```rust
use rs_poker::core::Deck;

assert_eq!(52, Deck::default().len());
```
```

--------------------------------

### MonteCarloGame::reset

Source: https://docs.rs/rs_poker/latest/src/rs_poker/holdem/monte_carlo_game.rs.html

Resets the game state to its initial configuration, restoring the starting hands.

```APIDOC
## MonteCarloGame::reset

### Description
Resets the game state to its initial configuration, restoring the starting hands.

### Signature
`pub fn reset(&mut self)`
```

--------------------------------

### Run a Single Hold'em Simulation

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/index.html

Use `HoldemSimulationBuilder` to configure and run a single poker simulation. Requires setting up game state, agents, and a random number generator.

```rust
use rand::{SeedableRng, rngs::StdRng};
use rs_poker::arena::HoldemSimulationBuilder;
use rs_poker::arena::agent::CallingAgent;
use rs_poker::arena::agent::RandomAgent;
use rs_poker::arena::game_state::GameState;

let stacks = vec![100.0, 100.0];
let agents: Vec<Box<dyn rs_poker::arena::Agent>> = vec![
    Box::<CallingAgent>::default(),
    Box::<RandomAgent>::default(),
];
let mut rng = StdRng::seed_from_u64(420);

let game_state = GameState::new_starting(stacks, 10.0, 5.0, 0.0, 0);
let mut sim = HoldemSimulationBuilder::default()
    .game_state(game_state)
    .agents(agents)
    .build()
    .unwrap();

let result = sim.run(&mut rng);

```

--------------------------------

### GameState::player_reward

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Calculates the total reward for a player, which is the change in their stack from the start of the game.

```APIDOC
## GameState::player_reward

### Description
Calculates the total reward for a player, which is the change in their stack from the start of the game.

### Signature
```rust
pub fn player_reward(&self, player_idx: usize) -> f32
```

### Parameters
* `player_idx`: The index of the player to get the reward for.

### Returns
The total reward for the specified player.
```

--------------------------------

### Default Implementation

Source: https://docs.rs/rs_poker/latest/src/rs_poker/core/flat_deck.rs.html

Provides a default `FlatDeck`.

```APIDOC
## Default

### Description
Creates a default `FlatDeck` by shuffling a standard 52-card deck.

### Method
`impl Default for FlatDeck`

### Parameters
None

### Returns
- `FlatDeck`: A new, shuffled `FlatDeck`.
```

--------------------------------

### Get Number of Agents

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/simulation.rs.html

Returns the total number of poker agents participating in the simulation.

```rust
/// Returns the number of poker agents participating in this simulation.
    pub fn num_agents(&self) -> usize {
        self.agents.len()
    }
```

--------------------------------

### HoldemSimulationBuilder: deck() method

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/sim_builder.rs.html

Sets the deck for the simulation. If not provided, a deck will be created from the game state and shuffled. Returns the builder.

```rust
pub fn deck(mut self, deck: Deck) -> Self {
    self.deck = Some(deck);
    self
}
```

--------------------------------

### Get Number of Active Players

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/game_state.rs.html

Returns the count of players currently active in the game.

```rust
pub fn num_active_players(&self) -> usize {
        self.player_active.count()
    }
```

--------------------------------

### GameState::current_round_player_bet

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/game_state/struct.GameState.html

Gets the current bet amount for a specific player in the current round.

```APIDOC
## GameState::current_round_player_bet

### Description
Gets the current bet amount for a specific player in the current round.

### Signature
```rust
pub fn current_round_player_bet(&self, idx: usize) -> f32
```

### Parameters
* `idx`: The index of the player.

### Returns
The bet amount of the specified player in the current round.
```

--------------------------------

### Build and Run Hold'em Simulation

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/cfr/agent.rs.html

Initializes a Hold'em simulation with specified game state and CFR agents, then runs the simulation using a random number generator.

```rust
let dyn_agents = agents.into_iter().map(|a| a as Box<dyn Agent>).collect();

        let mut rng = rand::rng();

        let mut sim = HoldemSimulationBuilder::default()
            .game_state(game_state)
            .agents(dyn_agents)
            .build()
            .unwrap();

        sim.run(&mut rng);
```

--------------------------------

### Get Chosen Child Index

Source: https://docs.rs/rs_poker/latest/rs_poker/arena/cfr/struct.TraversalState.html

Returns the index of the chosen child node in the TraversalState.

```rust
pub fn chosen_child_idx(&self) -> usize
```

--------------------------------

### Initialize Hold'em Competition

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/competition/holdem_competition.rs.html

Creates a new `HoldemCompetition` instance. Initializes metrics like round count, stack changes, win/loss counts, and round-before statistics to zero for all agents.

```rust
pub fn new(simulation_iterator: T) -> HoldemCompetition<T> {
        HoldemCompetition {
            simulation_iterator,
            max_sim_history: 100,
            // Set everything to zero
            num_rounds: 0,
            total_change: vec![0.0; MAX_PLAYERS],
            min_change: vec![0.0; MAX_PLAYERS],
            max_change: vec![0.0; MAX_PLAYERS],
            win_count: vec![0; MAX_PLAYERS],
            loss_count: vec![0; MAX_PLAYERS],
            zero_count: vec![0; MAX_PLAYERS],
            // Round before stopping
            before_count: HashMap::new(),
        }
    }
```

--------------------------------

### player_reward

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/game_state.rs.html

Calculates and returns the total reward for a player, which is the difference between their current stack and their starting stack.

```APIDOC
## player_reward

### Description
Calculates and returns the total reward for a player, which is the difference between their current stack and their starting stack.

### Method
`pub fn player_reward(&self, player_idx: usize) -> f32`

### Parameters
- `player_idx` (usize) - The index of the player to get the reward for.

### Returns
- `f32` - The total reward for the player.
```

--------------------------------

### Run Hold'em Simulation with Replay Agents

Source: https://docs.rs/rs_poker/latest/src/rs_poker/arena/agent/replay.rs.html

Sets up and runs a Texas Hold'em simulation using pre-defined actions from Replay Agents. Ensure agents are correctly boxed and actions are provided in the desired sequence.

```rust
let stacks = vec![2.8460483e26, 53477376.0];
        let game_state = GameState::new_starting(stacks, 8365616.5, 0.0, 0.0, 1);
        let agents: Vec<Box<dyn Agent>> = vec![agent_zero, agent_one];
        let mut rng = StdRng::seed_from_u64(0);

        let mut sim: HoldemSimulation = HoldemSimulationBuilder::default()
            .game_state(game_state)
            .agents(agents)
            .build()
            .unwrap();

        sim.run(&mut rng);

        assert_valid_game_state(&sim.game_state);
```
Tokens:
Raw