From 314bf6c85b3cb8ab1c6865f34a28bf95c523bfe5 Mon Sep 17 00:00:00 2001
From: Teppy <teppy@egenesis.com>
Date: Tue, 11 Jun 2024 17:44:11 -0400
Subject: [PATCH] changes

---
 src/main.rs | 51 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 28 insertions(+), 23 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 53da393..14e8ddf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -76,13 +76,18 @@ impl RoyaltyTree {
         RoyaltyTree { tree:Vec::new() }
 	}
     fn weight_here_below(&self, index:usize) -> FiNum {
-        if index<self.tree.len() { self.tree[index].weight} else { FiNum::zero() }
+        let mut point=index;
+	while point>=self.tree.len() && point&1==1 { point=wt_left(point).unwrap() }
+	if point<self.tree.len() { self.tree[point].weight }
+	else                     { FiNum::zero() }
 	}
-    fn weight_below(&self, index:usize) -> FiNum {
+    fn weight_below(&self, index: usize) -> FiNum {
         if index&1==0 {
 	    FiNum::zero()
 	} else {
-	    self.weight_here_below(wt_left (index).unwrap())+self.weight_here_below(wt_right(index).unwrap())
+            let w0=self.weight_here_below(wt_left (index).unwrap());
+	    let w1=self.weight_here_below(wt_right(index).unwrap());
+	    w0+w1
 	    }
 	}
     fn weight_here(&self, index:usize) -> FiNum {
@@ -114,9 +119,10 @@ impl RoyaltyTree {
 		let d0=d02*self.weight_here_below(index_left)/self.weight_below(index);
 		let d2=d02-d0;
 		assert!(lazy==d0+d1+d2,"Distributing amounts that don't add up.");
-		self.expand_to(index_right);
 		self.tree[index_left ].lazy+=d0;
-		self.tree[index_right].lazy+=d2;
+		// 
+		if index_right<self.tree.len() { self.tree[index_right].lazy+=d2; }
+		else if !d2.is_zero() { println!("Index {} Lazy {} D0 {} D1 {} D2 {} D02 {}",index,lazy,d0,d1,d2,d02); }
 		self.tree[index].acc+=d1;
 		self.tree[index].lazy=FiNum::zero();
 		}
@@ -130,39 +136,35 @@ impl RoyaltyTree {
 	    f=if f>index { wt_left(f).unwrap() } else { wt_right(f).unwrap() }
 	    }
 	self.capture0(f);
-	self.tree[index].acc
-	}
-    fn capture(&mut self, index: usize) {
-        let f=self.forefather();
-	let mut index=index;
-	while index!=f {
-	    self.capture0(index);
-	    index=wt_parent(index);
-	    }
-	self.capture0(index);
+	if index<self.tree.len() { self.tree[index].acc } else { FiNum::zero() }
 	}
     fn add_royalty(&mut self, amount: FiNum) {
         let ff=self.forefather();
         self.tree[ff].lazy+=amount;
+	println!("Add royalty amount {}, storing at node {}, lazy amount there is now {}",amount,ff,self.tree[ff].lazy);
 	}
     fn insert(&mut self, weight: FiNum) {
+        if self.tree.len()>0 { self.get_royalty(self.tree.len()-1); }
         self.tree.push(Royalty::new());
 	let mut index=self.tree.len()-1;
+        println!("Inserting at {}",index);
         if index&1==1 {
             let left_weight=self.tree[wt_left(index).unwrap()].weight;
             self.tree[index].weight=left_weight;
+	    println!("    Non-leaf, weight inherets from left, {}",self.tree[index].weight);
             }
-        println!("Inserting at {}",index);
 	let rval=index;
 	let ff=self.forefather();
+	println!("    Forefather node is {}",ff);
 	while index!=ff {
-            println!("Index {} Adding weight {}",index,weight);
-    	    self.tree[index].weight+=weight;
+    	    if index<self.tree.len() {
+	        self.tree[index].weight+=weight;
+                println!("    Added weight {} to index {}, weight is now {}",weight,index,self.tree[index].weight);
+		}
 	    index=wt_parent(index);
 	    }
-        println!("Index {} Adding weight {}",index,weight);
 	self.tree[index].weight+=weight;
-        println!("Index {} Final weight {}",index,self.tree[index].weight);
+        println!("    Final add weight {} to index {}, weight is now {}",weight,index,self.tree[index].weight);
 	}
     fn forefather(&self) -> usize {
         wt_forefather(self.tree.len()-1)
@@ -457,6 +459,10 @@ fn wt_left(index:usize) -> Option<usize> {
     if level>0 { Some(index-(1<<(wt_level(index)-1))) } else { None }
     }
 
+fn wt_first_left(index: usize, edge: usize) -> Option<usize> { // Includes edge
+    
+    }
+
 fn wt_right(index:usize) -> Option<usize> {
     let level=wt_level(index);
     if level>0 { Some(index+(1<<(wt_level(index)-1))) } else { None }
@@ -492,13 +498,12 @@ fn tree_stuff() {
 
 fn royalty_stuff() {
     let mut rt=RoyaltyTree::new();
-    for _ in 0..2 {
+    for _ in 0..6 {
         let index=rt.insert(FiNum::new_i32(10));
 	rt.add_royalty(FiNum::new_i32(24))
 	}
-    rt.dump();
     for index in 0..rt.tree.len() {
-        println!("Index: {} Royalty: {}",index,rt.weight_here_below(index));
+        println!("Index: {} Weight_here {} Weight_below {} Weight_here_below {}",index,rt.weight_here(index),rt.weight_below(index),rt.weight_here_below(index));
         }
     }