Changes

src/main.rs

@@ -1,10 +1,20 @@
+//
+// When inserting a new Order into the royalties tree, we must make sure the existing
+// royalties don't get shared with that new node. To do this, we must "shave" down
+// the tree, pushing royalties from the root down to all nodes to the left of the
+// new node.
+//
+// Case to think about:
+//   Selling 140000 USD to buy 2 BTC. Weight is ===140k USD
+//   Selling  50000 GBP to buy 1 BTC. Weight is === 50k GBP 
+//
 #![allow(unsafe_code)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
 use std::env;
 use std::collections::HashMap;
 use std::cmp::Ordering;
-use std::cmp::min;
 use std::rc::Rc;
-use std::ops::DerefMut;
 use std::cell::RefCell;
 use rand::prelude::*;
 use rand::rngs::StdRng;
@@ -13,25 +23,25 @@ use finum::FiNum;
 #[derive(Debug, Clone)]
 struct Trader {
     name: String,
-    id: i32,    
-    balances: HashMap<i32,FiNum>, // Maps Currency to Amount
+    id: usize,    
+    balances: HashMap<usize,FiNum>, // Maps Currency to Amount
     }
 
 impl Trader {
-    fn new(name:&str,id:i32) -> Self {
+    fn new(name:&str,id:usize) -> Self {
         Trader {
             name: String::from(name),
             id: id,
             balances: HashMap::new()
             }
         }
-    fn add_balance(&mut self, cur:i32, delta:FiNum) {
+    fn add_balance(&mut self, cur:usize, delta:FiNum) {
         self.balances.entry(cur).and_modify(|ent| *ent+=delta ).or_insert_with(|| delta);
         }
-    fn sub_balance(&mut self, cur:i32, delta:FiNum) {
+    fn sub_balance(&mut self, cur:usize, delta:FiNum) {
         self.balances.entry(cur).and_modify(|ent| *ent-=delta );
         }
-    fn get_balance(&self, cur:i32) -> FiNum {
+    fn get_balance(&self, cur:usize) -> FiNum {
         *self.balances.get(&cur).map(|bal| bal).unwrap_or(&FiNum::new(0u64))
         }
     }
@@ -41,14 +51,56 @@ struct Order {
     sell_qty: FiNum,
     sell_remain: FiNum,
     buy_qty: FiNum,
-    owner: i32,
+    owner: usize,
+    rt_loc: usize,        // Location in the Royalty Tree
     }
 
+struct RoyaltyTree {
+    tree: Vec<Royalty>,
+    }
+
+impl RoyaltyTree {
+    fn new() -> Self {
+         RoyaltyTree { tree:Vec::new() }
+	 }
+    }
+
+struct Royalty {
+    weight: FiNum,      // Here and below
+    acc: FiNum,         // Here and Below
+    }
+
+impl Royalty {
+    fn new(weight: FiNum) -> Self {
+        Royalty { weight:weight, acc:FiNum::new(0u64) }
+        }
+    }
+
+impl RoyaltyTree {
+    fn insert(&mut self, weight: FiNum) -> usize {
+        self.tree.push(Royalty::new(weight));
+        let last=self.tree.len()-1;
+        let forefather=wt_forefather(last);
+        let mut pivot=last;
+        while pivot!=forefather {
+            pivot=wt_parent(pivot);
+	    for i in self.tree.len()-1..=pivot {
+	        self.tree.push(Royalty::new(0.into()));
+		self.tree[i].weight=if let Some(v)=wt_left (i) { self.tree[v].weight } else { FiNum::zero() }
+		                   +if let Some(v)=wt_right(i) { self.tree[v].weight } else { FiNum::zero() };
+	        }
+            }
+        self.tree[last].weight+=weight;
+	last
+        }
+    }
+        
+
 trait Dumpable {
     fn dump(&self);
     }
 
-impl Dumpable for i32 {
+impl Dumpable for usize {
     fn dump(&self) {
         println!("Dump Integer: {}",self);
         }
@@ -70,30 +122,33 @@ impl Dumpable for Order {
 
 
 struct Market {
-    asset_name2num: HashMap<String,i32>,
-    asset_num2name: HashMap<i32,String>,
-    asset_count:i32,
-    money_supply: HashMap<i32,FiNum>,
+    asset_name2num: HashMap<String,usize>,
+    asset_num2name: HashMap<usize,String>,
+    asset_count:usize,
+    money_supply: HashMap<usize,FiNum>,
     traders: Vec<Trader>,
-    trader_name2num: HashMap<String,i32>,
-    orders: HashMap<(i32,i32),PQueue<Rc<RefCell<Order>>>>,
-    royalties: HashMap<i32,Vec<Rc<RefCell<Order>>>>, // Active orders that are accepting asset X. They receive royalties when someone makes an order to sell X
+    trader_name2num: HashMap<String,usize>,
+    orders: HashMap<(usize,usize),PQueue<Rc<RefCell<Order>>>>,
+    royalties: HashMap<usize,RoyaltyTree>, // Active orders that are accepting asset X. They receive royalties when someone makes an order to sell X
     }
 
 impl Market {
     fn new() -> Self {
-        Market {
+        let mut rval=Market {
             asset_name2num: HashMap::new(),
             asset_num2name: HashMap::new(),
             asset_count:0,
             money_supply: HashMap::new(),
             orders: HashMap::new(),
-	    royalties: HashMap::new(),
+            royalties: HashMap::new(),
             traders: Vec::new(),
             trader_name2num: HashMap::new(),
-            }
+            };
+	rval.register_trader("*NONE*");
+	rval
         }
     fn distribute_royalty(&self, amount:FiNum) {
+        
         }
     fn sanity_check(&self) {
         println!("Sanity Checking Market...");
@@ -109,32 +164,32 @@ impl Market {
             println!("    {}: Orders {} Traders {} Total {} Should Be {}",self.number_to_name(*cur),acc_orders,acc_traders,acc,*amt);
             }
         }
-    fn register_trader(&mut self, name:&str) -> i32 { // Add error checking for inserting a trader twice
-        let rval=self.traders.len() as i32;
-        self.trader_name2num.insert(String::from(name),self.traders.len() as i32);
+    fn register_trader(&mut self, name:&str) -> usize { // Add error checking for inserting a trader twice
+        let rval=self.traders.len();
+        self.trader_name2num.insert(String::from(name),self.traders.len());
         self.traders.push(Trader::new(name,rval));
         rval
         }
     // These are the only ways to get money into or out of the market.
-    fn add_trader_balance(&mut self, who:i32, cur:i32, delta: FiNum) {
+    fn add_trader_balance(&mut self, who:usize, cur:usize, delta: FiNum) {
         self.traders[who as usize].add_balance(cur,delta);
         *self.money_supply.get_mut(&cur).unwrap()+=delta;
         }
-    fn sub_trader_balance(&mut self, who:i32, cur:i32, delta: FiNum) {
+    fn sub_trader_balance(&mut self, who:usize, cur:usize, delta: FiNum) {
         self.traders[who as usize].sub_balance(cur,delta);
         *self.money_supply.get_mut(&cur).unwrap()-=delta;
         }
-    fn register_asset(&mut self, name:&str) -> i32 {
+    fn register_asset(&mut self, name:&str) -> usize {
         self.asset_count+=1;
         self.asset_name2num.insert(String::from(name),self.asset_count);
         self.asset_num2name.insert(self.asset_count,String::from(name));
         self.money_supply.insert(self.asset_count,FiNum::new(0));
         self.asset_count
         }
-    fn name_to_number(&self, name:&str) -> i32 {
+    fn name_to_number(&self, name:&str) -> usize {
         *self.asset_name2num.get(name).unwrap()
         }
-    fn number_to_name(&self, num:i32) -> &str {
+    fn number_to_name(&self, num:usize) -> &str {
         &*self.asset_num2name.get(&num).unwrap()
         }
     fn dump(&self) {
@@ -150,7 +205,7 @@ impl Market {
             let mut sorted=pq.v.clone();
             sorted.sort_by(|a,b| { let a=a.borrow(); let b=b.borrow(); (a.sell_qty/a.buy_qty).cmp(&(b.sell_qty/b.buy_qty)) });
             for off in sorted.iter() {
-	        let off=off.borrow();
+                let off=off.borrow();
                 println!("    {} @ {} ({})",
                          off.sell_remain,              // off.buy_qty*off.sell_remain/off.sell_qty,
                          off.buy_qty/off.sell_qty,
@@ -159,7 +214,7 @@ impl Market {
             pq.dump();
             }
         }
-    fn make_order(&mut self, owner:i32, sell_type:i32, buy_type:i32, sell_qty_initial:FiNum, buy_qty_initial:FiNum) -> bool // Dollars, Bitcoin, 64000, 1
+    fn make_order(&mut self, owner:usize, sell_type:usize, buy_type:usize, sell_qty_initial:FiNum, buy_qty_initial:FiNum) -> bool // Dollars, Bitcoin, 64000, 1
         {
         let initial_balance=self.traders[owner as usize].get_balance(sell_type);
         if initial_balance<sell_qty_initial { return false; }
@@ -176,7 +231,7 @@ impl Market {
                 self.traders[owner     as usize].add_balance(buy_type ,qty); 
                 self.traders[elt.owner as usize].add_balance(sell_type,pay_qty);
                 if elt.sell_remain==0.into() { self.orders.get_mut(&ap).unwrap().pop(); }
-		else { self.orders.get(&ap).unwrap().v[0].borrow_mut().sell_remain-=qty; }
+                else { self.orders.get(&ap).unwrap().v[0].borrow_mut().sell_remain-=qty; }
             } else { break; }
             }
         if buy_qty>0.into() {
@@ -185,7 +240,9 @@ impl Market {
             let bids=self.orders.get_mut(&ap).unwrap();
             let sell_qty_remain=sell_qty_initial*buy_qty/buy_qty_initial;
             if sell_qty_remain>0.into() {
-	        let neworder=Rc::new(RefCell::new(Order { owner:owner, sell_qty:sell_qty_remain, sell_remain:sell_qty_remain, buy_qty:buy_qty } ));
+	        let rt_loc=self.royalties.entry(sell_type).or_insert(RoyaltyTree::new()).insert(sell_qty_remain);
+                let neworder=Rc::new(RefCell::new(
+		    Order { owner:owner, sell_qty:sell_qty_remain, sell_remain:sell_qty_remain, buy_qty:buy_qty, rt_loc: rt_loc } ));
                 bids.insert(neworder);
                 self.traders[owner as usize].sub_balance(sell_type,sell_qty_remain);
                 }
@@ -274,17 +331,17 @@ impl<T: Dumpable + std::cmp::PartialOrd + std::fmt::Debug> PQueue<T> {
 impl Market {
     fn exercise(&mut self) {
         let mut rng: StdRng=StdRng::seed_from_u64(13u64);
-	let teppy=self.register_trader("Teppy");  
-	let luni =self.register_trader("Luni");
-	let usd  =self.register_asset("USD");
-	let btc  =self.register_asset("BTC");
-	self.add_trader_balance(teppy,btc,100000.into());
-	self.add_trader_balance(luni ,usd,650000000.into());
-	let mut count=0;
-	let mut tries=0;
-	for _i in 1..=10000000 {
+        let teppy=self.register_trader("Teppy");  
+        let luni =self.register_trader("Luni");
+        let usd  =self.register_asset("USD");
+        let btc  =self.register_asset("BTC");
+        self.add_trader_balance(teppy,btc,100000.into());
+        self.add_trader_balance(luni ,usd,650000000.into());
+        let mut count=0;
+        let mut tries=0;
+        for _i in 1..=10000000 {
             let seller=if rng.gen_bool(0.5) { teppy } else { luni };
-            let (buy_type,sell_type,buy_qty,sell_qty):(i32,i32,FiNum,FiNum);
+            let (buy_type,sell_type,buy_qty,sell_qty):(usize,usize,FiNum,FiNum);
             if rng.gen_bool(0.5) {
                 sell_type=btc;
                 buy_type=usd;
@@ -298,7 +355,7 @@ impl Market {
                 }
             let mut _success=false;
             if self.make_order(seller,sell_type,buy_type,sell_qty,buy_qty) { count+=1; _success=true; };
-	    if count>=1000000 { break; }
+            if count>=1000000 { break; }
             tries+=1;
             }
         println!("Tries: {} Trades: {}",tries,count);
@@ -306,21 +363,21 @@ impl Market {
         }
     }
 
-fn wt_level(index:u64) -> u32 {
-    (index^(index+1)).trailing_ones()-1
+fn wt_level(index:usize) -> usize {
+    (index^(index+1)).trailing_ones() as usize-1
     }
 
-fn wt_left(index:u64) -> Option<u64> {
+fn wt_left(index:usize) -> Option<usize> {
     let level=wt_level(index);
     if level>0 { Some(index-(1<<(wt_level(index)-1))) } else { None }
     }
 
-fn wt_right(index:u64) -> Option<u64> {
+fn wt_right(index:usize) -> Option<usize> {
     let level=wt_level(index);
     if level>0 { Some(index+(1<<(wt_level(index)-1))) } else { None }
     }
 
-fn wt_parent(index:u64) -> u64 {
+fn wt_parent(index:usize) -> usize {
     let lev=wt_level(index);
     let first_in_row=index%(1<<lev);
     let skip=2<<lev;
@@ -331,7 +388,7 @@ fn wt_parent(index:u64) -> u64 {
     first_in_parent_row+nth_in_parent_row*skip_in_parent_row
     }
 
-fn wt_forefather(max_index:u64) -> u64 {
+fn wt_forefather(max_index:usize) -> usize {
     let mut rval=max_index;
     rval=rval|(rval>>1);
     rval=rval|(rval>>2);
@@ -345,7 +402,7 @@ fn wt_forefather(max_index:u64) -> u64 {
 fn tree_stuff() {
     for i in (0..=60).step_by(1) {
         println!("Index {} Forefather {} Parent {}",i,wt_forefather(i),wt_parent(i));
-	}
+        }
     }
 
 
@@ -355,7 +412,7 @@ fn main() {
     let mut m=Market::new(); // USD type is 1, EUR type is 2, BTC type is 10, ETH type is 11, zKN6FBdD SOL type is 12
     match mode {
         "--exercise" => m.exercise(),
-	"--treestuff" => tree_stuff(),
-	_ => println!("Unknown mode: {}",mode),
-	}
+        "--treestuff" => tree_stuff(),
+        _ => println!("Unknown mode: {}",mode),
+        }
     }