From cab5c40d08990632a584670e6705ce0a8b041c23 Mon Sep 17 00:00:00 2001
From: Teppy <teppy@egenesis.com>
Date: Sun, 29 Sep 2024 08:09:22 -0400
Subject: [PATCH 1/2] Updated Cargo.toml

---
 Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Cargo.toml b/Cargo.toml
index 63da070..803ad98 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,4 +8,5 @@ debug = true
 [dependencies]
 rand="0.8.5"
 finum={ path="../finum" }
+hashbrown="0.14.5"
 

From 26051ccda6997a0447678f86f90a76ff4fd5575d Mon Sep 17 00:00:00 2001
From: Andrew Tepper <teppy@egenesis.com>
Date: Mon, 30 Sep 2024 15:06:22 -0400
Subject: [PATCH 2/2] changes

---
 src/main.rs | 60 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 34 insertions(+), 26 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 6b5a64d..0befb64 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -251,27 +251,37 @@ impl RoyaltyTree {
         if self.tree.len()==0 { return None }
         let mut f=self.forefather();
 	while self.count_here_below(f)>0 {
+	    if f&1==0 { return Some(f); }
             let c0=self.count_here(f);
-	    let c1=if f&1==0 { 0 } else { self.count_here_below(wt_left(f).unwrap()) };
-	    let c2=if f&1==0 { 0 } else { self.count_here_below(wt_right(f).unwrap()) };
+	    let c1=if f&1==0 { self.count_here(f) } else { self.count_here_below(wt_left(f).unwrap()) };
+	    let c2=if f&1==0 { self.count_here(f) } else { self.count_here_below(wt_right(f).unwrap()) };
 	    let c=c0+c1+c2;
 	    let r=rng.gen_range(0..c);
-	    if      r<c0 { return Some(f) }
-	    else if r<c1 { f=wt_left(f).unwrap() }
-	    else         { f=wt_right(f).unwrap() }
+	    if      r<c0    { println!("returning {}",f); return Some(f) }
+	    else if r<c0+c1 { f=wt_left(f).unwrap() }
+	    else            { f=wt_right(f).unwrap() }
 	    }
 	None
         }
     fn capture_partial(&mut self, id: usize, weight: FiNum) -> FiNum {
         FiNum::zero()
         }
-    fn sub_weight(&mut self, index: usize, weight: FiNum) {
+    fn sub_weight(&mut self, index: usize, mut weight: FiNum) {
         self.get_royalty(index);
-        let redist=self.tree[index].acc;
-        self.tree[index].acc=FiNum::zero();
+	let delta_count;
+	let wh=self.weight_here(index);
+	let redist=if weight>=wh { delta_count=if wh>FiNum::zero() { 1 } else { 0 }; weight=wh; self.tree[index].acc }
+        else { delta_count=0; self.tree[index].acc*weight/wh };
+        self.tree[index].acc-=redist;
         let mut index=index;
         let ff=self.forefather();
-        while index!=ff { self.tree[index].weight-=weight; index=wt_parent(index); }
+	if delta_count>0 { println!("YES ITS > 0"); }
+        while index!=ff {
+	    self.tree[index].weight-=weight;
+	    self.tree[index].count-=delta_count;
+	    if index==ff { break; }
+	    index=wt_parent(index);
+	    }
         self.add_royalty(redist);
         }
     fn set_location(&mut self, id: usize, index: usize) {
@@ -286,7 +296,7 @@ impl RoyaltyTree {
 	    self.expand_to(ff1*2);
 	    while ff0<ff1 {
 	        ff0=wt_parent(ff0);
-                println!("Setting self.tree[{}].weight to {}",ff0,self.tree[ff0].weight);
+                println!("Setting self.tree[{}].weight to {} and count to {}",ff0,w,c);
 		self.tree[ff0].weight=w;
 		self.tree[ff0].count=c;
 		}
@@ -294,19 +304,14 @@ impl RoyaltyTree {
 	else { self.expand_to(wt_forefather(index)*2); }
         self.get_royalty(index); // Just for the side effect of capturing everything to this point
         let mut index=index;
+	let delta_count=if self.weight_here(index)==FiNum::zero() { 1 } else { 0 };
 	let ff=self.forefather();
-        while index!=ff {
-            println!("self.tree[{}].weight={}",index,self.tree[index].weight);
-            if self.weight_here(index)==FiNum::zero() && weight>FiNum::zero() {
-                self.tree[index].count+=1;
-                }
+        loop {
             self.tree[index].weight+=weight;
+	    self.tree[index].count+=delta_count;
+	    if index==ff { break; }
             index=wt_parent(index);
-            }
-        if self.weight_here(index)==FiNum::zero() && weight>FiNum::zero() {
-            self.tree[index].count+=1;
-            }
-        self.tree[index].weight+=weight;
+	    }
         }
     fn forefather(&self) -> usize {
         wt_forefather(self.tree.len()-1)
@@ -805,16 +810,19 @@ fn royalty_stuff() {
     rt.dump();
     rt.add_weight(5,FiNum::new_i32(1));
     rt.dump();
-    return;
-    for i in 1..1000000 {
-        rt.dump();
+//    return;
+    for i in 1..10000 {
+//        rt.dump();
+        let node=rng.gen_range(0..10);
         match rng.gen_range(0..10) {
-            0 => rt.add_weight(rng.gen_range(0..8),FiNum::new_i32(rng.gen_range(0..101))),
-            1 => rt.add_royalty(FiNum::new_i32(rng.gen_range(0..10))),
-            2 => println!("Random Order ID: {:?}",rt.random_order_id(&mut rng)),
+            0 => { println!("Add at {}",node); rt.add_weight(node,FiNum::new_i32(rng.gen_range(0..101))) },
+	    1 => { println!("Sub at {}",node); rt.sub_weight(node,FiNum::new_i32(rng.gen_range(0..101))) },
+            2 => rt.add_royalty(FiNum::new_i32(rng.gen_range(0..10))),
+            3 => println!("Random Order ID: {:?}",rt.random_order_id(&mut rng)),
             _ => (),
 	    }
         }
+    rt.dump();
     }