borispf/dcfr - Change PXFEOQ4XPZFDGJN5GEQZDOKK5MTPXJIPWFNGBHOQRKPHHKR5CJMQC

refactor: pull rng out of game def

Created by borispf on April 3, 2023

PXFEOQ4XPZFDGJN5GEQZDOKK5MTPXJIPWFNGBHOQRKPHHKR5CJMQC

Dependencies

[2] RN7DWEQWABNYJGXEL6TLXEPJRHPDJ5QFWR2N7D42CTLPSGVJWFIAC

In channels

main

Change contents

Insertion in src/main.rs at line 10 [2.4054]
[2.4300]
[2.4300]
```
use rand::SeedableRng;
use rand_pcg::Pcg64Mcg;
```
Insertion in src/main.rs at line 15 [2.4054]
[2.4358]
[2.4358]
```
    let mut rng = Pcg64Mcg::seed_from_u64(4);
```

Replacement in src/main.rs at line 18 [2.4054]

B:BD[2.4441] → [2.4441:4481]

        cfr_trainer.single_iter(&game);

[2.4441]

[2.4481]

        cfr_trainer.single_iter(&game, &mut rng);

Replacement in src/main.rs at line 23 [2.4054]

B:BD[2.4614] → [2.4614:4654]

        cfr_trainer.single_iter(&game);

[2.4614]

[2.4654]

        cfr_trainer.single_iter(&game, &mut rng);

Replacement in src/main.rs at line 52 [2.4054]

B:BD[2.5630] → [2.5630:5873]

        expected_value(game, &|player, infoset| {
            let strat = &cfr_trainer.strategy_sum[&(player, infoset.clone())];
            let s_sum: f32 = strat.iter().sum();
            strat.iter().map(|s| s / s_sum).collect()
        })

[2.5630]

[2.5873]

        expected_value(
            game,
            &|player, infoset| {
                let strat = &cfr_trainer.strategy_sum[&(player, infoset.clone())];
                let s_sum: f32 = strat.iter().sum();
                strat.iter().map(|s| s / s_sum).collect()
            },
            &mut rng
        )

Insertion in src/lcfr.rs at line 3 [2.6111]
[2.6145]
[2.6145]
```
use rand::Rng;
```

Replacement in src/lcfr.rs at line 28 [2.6111]

B:BD[2.6813] → [2.6813:6857]

    pub fn single_iter(&mut self, game: &G)

[2.6813]

[2.6857]

    pub fn single_iter(&mut self, game: &G, rng: &mut impl Rng)

Replacement in src/lcfr.rs at line 34 [2.6111]

B:BD[2.7005] → [2.7005:7109]

        for player in game.players().as_ref() {
            self.walk(game, *player, 1, reach.clone());

[2.7005]

[2.7109]

        for &player in game.players().as_ref() {
            if player == Player::Chance {
                continue;
            }
            self.walk(game, player, 1, reach.clone(), rng);

Replacement in src/lcfr.rs at line 52 [2.6111]

B:BD[2.7504] → [2.7504:7591]

    pub fn walk(&mut self, game: &G, player: Player, t: usize, reach: ReachVec) -> f32

[2.7504]

[2.7591]

    pub fn walk(
        &mut self,
        game: &G,
        player: Player,
        t: usize,
        reach: ReachVec,
        rng: &mut impl Rng,
    ) -> f32

Replacement in src/lcfr.rs at line 71 [2.6111]

B:BD[2.7886] → [2.7886:7906]

            todo!()

[2.7886]

[2.7906]

            let mut game = game.clone();
            game.play_chance(rng);
            return self.walk(&game, player, t, reach, rng);

Replacement in src/lcfr.rs at line 101 [2.6111]

B:BD[2.8888] → [2.8888:8952]

            let v_s_i_a = self.walk(&mut ha, player, t, reach);

[2.8888]

[2.8952]

            let v_s_i_a = self.walk(&mut ha, player, t, reach, rng);

Replacement in src/lcfr.rs at line 141 [2.6111]

B:BD[2.10274] → [2.10274:10350]

pub fn expected_value<G, FnStrat>(game: G, strategy: &FnStrat) -> ActionVec

[2.10274]

[2.10350]

pub fn expected_value<G, FnStrat>(game: G, strategy: &FnStrat, rng: &mut impl Rng) -> ActionVec

Insertion in src/lcfr.rs at line 151 [2.6111]
[2.10540]
[2.10540]
```
            .filter(|&&p| p != Player::Chance)
```

Insertion in src/lcfr.rs at line 156 [2.6111]

[2.10634]

    if p == Player::Chance {
        let mut ev: ActionVec = game
            .players()
            .as_ref()
            .into_iter()
            .filter(|&&p| p != Player::Chance)
            .map(|_| 0.0)
            .collect();
        for i in 0..100 {
            let mut game = game.clone();
            game.play_chance(rng);
            ev.iter_mut()
                .zip(expected_value(game, strategy, rng))
                .for_each(|(evp, vp)| *evp += (vp - *evp) / (i + 1) as f32);
        }
        return ev;
    }

Replacement in src/lcfr.rs at line 174 [2.6111]

B:BD[2.10670] → [2.10670:10758]

    let mut ev: ActionVec = game.players().as_ref().into_iter().map(|_| 0.0).collect();

[2.10670]

[2.10758]

    let mut ev: ActionVec = game
        .players()
        .as_ref()
        .into_iter()
        .filter(|&&p| p != Player::Chance)
        .map(|_| 0.0)
        .collect();

Replacement in src/lcfr.rs at line 187 [2.6111]

B:BD[2.10910] → [2.10910:10953]

            expected_value(game, strategy)

[2.10910]

[2.10953]

            expected_value(game, strategy, rng)

Replacement in src/kuhn.rs at line 4 [2.11193]
B:BD[2.11242] → [2.11242:11285]
```
use rand::{seq::SliceRandom, SeedableRng};
```
[2.11242]
[2.11285]
```
use rand::{seq::SliceRandom, Rng};
```
Deletion in src/kuhn.rs at line 79 [2.11193]
B:BD[2.12254] → [2.12254:12280]
```
    rng: rand_pcg::Pcg64,
```
Replacement in src/kuhn.rs at line 85 [2.11193]
B:BD[2.12379] → [2.12379:12415]
```
    pub fn new(seed: u64) -> Self {
```
[2.12379]
[2.12415]
```
    pub fn new() -> Self {
```
Deletion in src/kuhn.rs at line 97 [2.11193]
B:BD[2.12804] → [2.12804:12855]
```
            rng: SeedableRng::seed_from_u64(seed),
```

Deletion in src/kuhn.rs at line 155 [2.11193]

B:BD[2.14531] → [2.14531:14858]

            Action::Shuffle => {
                self.deck.shuffle(&mut self.rng);
                for i in 1..=N {
                    self.push_history(History(Player::from_usize(i), Action::Deal(self.deck[i])));
                    self.bets[i - 1] = 1;
                }
                self.current_bet = 1;
            }

Insertion in src/kuhn.rs at line 168 [2.11193]

[2.15464]

            Action::Shuffle => unreachable!("call play_chance() instead"),

Insertion in src/kuhn.rs at line 173 [2.11193]

[2.15675]

    }
    fn play_chance(&mut self, rng: &mut impl Rng) -> f32 {
        self.deck.shuffle(rng);
        for i in 1..=N {
            self.push_history(History(Player::from_usize(i), Action::Deal(self.deck[i])));
            self.bets[i - 1] = 1;
        }
        self.current_bet = 1;
        self.current_player = Player::Agent1;
        1.0 / (1..=N + 1).product::<usize>() as f32

Insertion in src/kuhn.rs at line 211 [2.11193]

[2.16331]

    use rand::SeedableRng;
    use rand_pcg::Pcg64Mcg;

Replacement in src/kuhn.rs at line 224 [2.11193]
B:BD[2.16534] → [2.16534:16572]
```
        let kuhn = Kuhn::<2>::new(4);
```
[2.16534]
[2.16572]
```
        let kuhn = Kuhn::<2>::new();
```

Replacement in src/kuhn.rs at line 232 [2.11193]

B:BD[2.16760] → [2.16760:16802]

        let mut kuhn = Kuhn::<2>::new(4);

[2.16760]

[2.16802]

        let mut kuhn = Kuhn::<2>::new();
        let mut rng = Pcg64Mcg::seed_from_u64(4);

Replacement in src/kuhn.rs at line 237 [2.11193]

B:BD[2.16884] → [2.16884:16969]

        assert_eq!(kuhn.actions().as_ref(), &[Shuffle]);
        kuhn.play(Shuffle);

[2.16884]

[2.16969]

        kuhn.play_chance(&mut rng);

Replacement in src/kuhn.rs at line 270 [2.11193]

B:BD[2.17986] → [2.17986:18056]

        let mut kuhn = Kuhn::<2>::new(4);
        kuhn.play(Shuffle);

[2.17986]

[2.18056]

        let mut kuhn = Kuhn::<2>::new();
        let mut rng = Pcg64Mcg::seed_from_u64(4);
        kuhn.play_chance(&mut rng);

Insertion in src/game.rs at line 7 [2.18467]
[2.18524]
[2.18524]
```
use rand::Rng;
```

Insertion in src/game.rs at line 69 [2.18467]

[2.19489]

    fn play_chance(&mut self, _rng: &mut impl Rng) -> f32 {
        unimplemented!("this game does not support chance events");
    }