fix filter of Edge::Draw in Path Vec<Edge> bijection

Author: krukah

src/mccfr/blueprint.rs

@@ -116,16 +116,12 @@ impl Solver {
     /// continuing Edge Actions.
     /// fn explore(&mut self, tree: &mut Tree,node: &Node) -> Vec<Branch> {
     fn explore(&mut self, node: &Node) -> Vec<Branch> {
-        use crate::gameplay::ply::Ply;
-        // INCORRECT
         let branches = self.sampler.branches(node);
         let walker = self.profile.walker();
         let chance = Player::chance();
         let player = node.player();
         match (branches.len(), player) {
-            (0, p) => {
-                // INCORRECT
-                assert!(p.0 == Ply::Terminal);
+            (0, _) => {
                 vec![] //
             }
             (_, p) if p == chance => {

src/mccfr/node.rs

@@ -66,19 +66,6 @@ impl<'tree> Node<'tree> {
 
     // Navigational methods
 
-    /// if we were to play this edge, what would the
-    /// history: Vec<Edge> of the resulting Node be?
-    #[allow(dead_code)]
-    fn chained(&self, edge: &Edge) -> Vec<Edge> {
-        self.history()
-            .into_iter()
-            .rev()
-            .chain(std::iter::once(edge))
-            .rev()
-            .take_while(|e| e.is_choice())
-            .copied()
-            .collect()
-    }
     pub fn history(&self) -> Vec<&'tree Edge> {
         if let (Some(edge), Some(head)) = (self.incoming(), self.parent()) {
             let mut history = head.history();
@@ -138,8 +125,9 @@ impl<'tree> Node<'tree> {
         Bucket::from((subgame, present, choices))
     }
 
-    /// TODO
-    /// compare to self::futures()
+    /// determine the set of branches that could be taken from this node
+    /// this determines what Bucket we end up in since Tree::attach()
+    /// uses this to assign Buckets to Data upon insertion
     pub fn branches(&self) -> Vec<(Edge, Game)> {
         self.stale_continuations()
             .into_iter()
@@ -233,6 +221,19 @@ impl<'tree> Node<'tree> {
             .copied()
             .collect()
     }
+    /// if we were to play this edge, what would the
+    /// history: Vec<Edge> of the resulting Node be?
+    #[allow(dead_code)]
+    fn chained(&self, edge: &Edge) -> Vec<Edge> {
+        self.history()
+            .into_iter()
+            .rev()
+            .chain(std::iter::once(edge))
+            .rev()
+            .take_while(|e| e.is_choice())
+            .copied()
+            .collect()
+    }
 }
 
 impl std::fmt::Display for Node<'_> {

src/mccfr/path.rs

@@ -15,11 +15,12 @@ impl Arbitrary for Path {
 /// we (un)pack the byte representation of the edges in a Path(u64) sequence
 impl From<Path> for Vec<Edge> {
     fn from(path: Path) -> Self {
-        (0..16)
-            .map(|i| ((path.0 >> (i * 4)) & 0xF) as u8)
-            .filter(|&bits| bits != 0)
+        (0..)
+            .map(|i| i * 4)
+            .map(|b| 0xF & (path.0 >> b))
+            .map(|bits| bits as u8)
+            .take_while(|bits| bits != &0)
             .map(Edge::from)
-            .take_while(|e| e.is_choice())
             .collect()
     }
 }
@@ -28,10 +29,12 @@ impl From<Vec<Edge>> for Path {
         assert!(edges.len() <= 16);
         edges
             .into_iter()
+            .map(u8::from)
+            .map(|byte| byte as u64)
             .enumerate()
-            .map(|(i, edge)| (i, u8::from(edge)))
-            .map(|(i, byte)| (byte as u64) << (i * 4))
-            .fold(Self::default(), |Self(acc), bits| Self(acc | bits))
+            .map(|(i, byte)| byte << (i * 4))
+            .fold(0u64, |acc, bits| acc | bits)
+            .into()
     }
 }
 

src/mccfr/profile.rs

@@ -40,6 +40,10 @@ pub struct Profile {
 }
 
 impl Profile {
+    /// count of Buckets visited so far
+    pub fn size(&self) -> usize {
+        self.strategies.len()
+    }
     /// increment Epoch counter
     /// and return current count
     pub fn next(&mut self) -> usize {