talezero/lzf1
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changes

Browse Source
This commit is contained in:
Teppy
2024-05-26 08:19:55 -04:00
parent 9e29ce2ada
commit b3cfc9d173
1 changed files with 107 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
src/main.rs
View File

@@ -1,8 +1,11 @@
#![allow(unsafe_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;
use finum::FiNum;
@@ -34,7 +37,7 @@ impl Trader {
}
#[derive(Debug, Clone)]
struct Offer {
struct Order {
sell_qty: FiNum,
sell_remain: FiNum,
buy_qty: FiNum,
@@ -51,19 +54,27 @@ impl Dumpable for i32 {
}
}
impl Dumpable for Offer {
impl Dumpable for Rc<RefCell<Order>> {
fn dump(&self) {
}
}
impl Dumpable for Order {
fn dump(&self) {
println!("Giving {}/{} to get {}",self.sell_remain,self.sell_qty,self.buy_qty);
}
}
struct Market {
asset_name2num: HashMap<String,i32>,
asset_num2name: HashMap<i32,String>,
asset_count:i32,
money_supply: HashMap<i32,FiNum>,
offers: HashMap<(i32,i32),PQueue<Offer>>,
orders: HashMap<(i32,i32),PQueue<Rc<RefCell<Order>>>>,
traders: Vec<Trader>,
trader_name2num: HashMap<String,i32>,
}
@@ -75,7 +86,7 @@ impl Market {
asset_num2name: HashMap::new(),
asset_count:0,
money_supply: HashMap::new(),
offers: HashMap::new(),
orders: HashMap::new(),
traders: Vec::new(),
trader_name2num: HashMap::new(),
}
@@ -84,14 +95,14 @@ impl Market {
println!("Sanity Checking Market...");
for (cur,amt) in self.money_supply.iter() {
println!("Money Supply {}: {}",self.number_to_name(*cur),*amt);
let mut acc_offers=FiNum::new(0);
for (ac,pq) in &self.offers { if ac.0==*cur {
for off in &*pq.v { acc_offers+=off.sell_remain; }
let mut acc_orders=FiNum::new(0);
for (ac,pq) in &self.orders { if ac.0==*cur {
for off in &*pq.v { acc_orders+=off.sell_remain; }
} }
let mut acc_traders=FiNum::new(0);
for t in &self.traders { acc_traders+=t.get_balance(*cur); }
let acc=acc_offers+acc_traders;
println!(" {}: Offers {} Traders {} Total {} Should Be {}",self.number_to_name(*cur),acc_offers,acc_traders,acc,*amt);
let acc=acc_orders+acc_traders;
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
@@ -130,8 +141,8 @@ impl Market {
println!(" {}: {}",self.number_to_name(*cur),*bal)
}
}
for (ap,pq) in &self.offers {
println!("Offers selling {} to buy {}:",self.number_to_name(ap.0),self.number_to_name(ap.1));
for (ap,pq) in &self.orders {
println!("Orders selling {} to buy {}:",self.number_to_name(ap.0),self.number_to_name(ap.1));
let mut sorted=pq.v.clone();
sorted.sort_by(|a,b| (a.sell_qty/a.buy_qty).cmp(&(b.sell_qty/b.buy_qty)));
for off in sorted.iter() {
@@ -143,15 +154,15 @@ impl Market {
pq.dump();
}
}
fn make_offer(&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:i32, sell_type:i32, buy_type:i32, 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; }
// println!("INITIAL_BALANCE {} Selling {} {} to buy {} {}",initial_balance,sell_qty_initial,self.number_to_name(sell_type),buy_qty_initial,self.number_to_name(buy_type));
let mut buy_qty=buy_qty_initial;
let ap=(buy_type,sell_type);
while buy_qty>FiNum::new(0) && self.offers.contains_key(&ap) && self.offers.get(&ap).unwrap().v.len()>0 {
let elt=&mut self.offers.get_mut(&ap).unwrap().v[0];
while buy_qty>FiNum::new(0) && self.orders.contains_key(&ap) && self.orders.get(&ap).unwrap().v.len()>0 {
let elt=&mut self.orders.get_mut(&ap).unwrap().v[0];
if sell_qty_initial/buy_qty_initial>=elt.buy_qty/elt.sell_qty { // Transact at ask_rate
let qty=std::cmp::min(elt.sell_remain,buy_qty);
// println!("Transacting {} at {}/{}, not at {}/{}. Elt.sell_remain is {}",qty,elt.buy_qty,elt.sell_qty,sell_qty_initial,buy_qty_initial,elt.sell_remain);
@@ -164,16 +175,16 @@ impl Market {
self.traders[owner as usize].sub_balance(sell_type,pay_qty);
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.offers.get_mut(&ap).unwrap().pop(); }
if elt.sell_remain==0.into() { self.orders.get_mut(&ap).unwrap().pop(); }
} else { break; }
}
if buy_qty>0.into() {
let ap=(sell_type,buy_type);
if let None=self.offers.get_mut(&ap) { self.offers.insert(ap,PQueue::new()); }
let bids=self.offers.get_mut(&ap).unwrap();
if let None=self.orders.get_mut(&ap) { self.orders.insert(ap,PQueue::new()); }
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() {
bids.insert(Offer { owner:owner, sell_qty:sell_qty_remain, sell_remain:sell_qty_remain, buy_qty:buy_qty } );
bids.insert(Rc::new(RefCell::new(Order { owner:owner, sell_qty:sell_qty_remain, sell_remain:sell_qty_remain, buy_qty:buy_qty } )));
self.traders[owner as usize].sub_balance(sell_type,sell_qty_remain);
}
}
@@ -181,7 +192,7 @@ impl Market {
}
}
impl PartialOrd for Offer {
impl PartialOrd for Order {
fn partial_cmp(&self, other:&Self) -> Option<Ordering> {
let ord0=self .sell_qty/self .buy_qty;
let ord1=other.sell_qty/other.buy_qty;
@@ -191,7 +202,7 @@ impl PartialOrd for Offer {
}
}
impl PartialEq for Offer {
impl PartialEq for Order {
fn eq(&self, other:&Self) -> bool {
let ord0=self .sell_qty/self .buy_qty;
let ord1=other.sell_qty/other.buy_qty;
@@ -258,41 +269,80 @@ 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 debug_index=100000000;
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);
if rng.gen_bool(0.5) {
sell_type=btc;
buy_type=usd;
sell_qty=rng.gen_range(1..=5).into();
buy_qty=sell_qty*rng.gen_range(60..=70).into();
} else {
sell_type=usd;
buy_type=btc;
buy_qty=rng.gen_range(1..=5).into();
sell_qty=buy_qty*rng.gen_range(60..=70).into();
}
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; }
tries+=1;
}
println!("Tries: {} Trades: {}",tries,count);
self.sanity_check();
}
}
fn wt_level(index:u64) -> u32 {
(index^(index+1)).trailing_ones()-1
}
fn wt_left(index:u64) -> Option<u64> {
let level=wt_level(index);
if level>0 { Some(index-(1<<(wt_level(index)-1))) } else { None }
}
fn wt_right(index:u64) -> Option<u64> {
let level=wt_level(index);
if level>0 { Some(index+(1<<(wt_level(index)-1))) } else { None }
}
fn wt_parent(index:u64) -> u64 {
let lev=wt_level(index);
let first_in_row=index%(1<<lev);
let skip=2<<lev;
let nth_in_row=(index-first_in_row)/skip;
let first_in_parent_row=(2<<lev)-1;
let skip_in_parent_row=4<<lev;
let nth_in_parent_row=nth_in_row>>1;
first_in_parent_row+nth_in_parent_row*skip_in_parent_row
}
fn tree_stuff() {
for i in (0..=60).step_by(1) {
println!("Index {} Parent {}",i,wt_parent(i));
}
}
fn main() {
let mut rng: StdRng=StdRng::seed_from_u64(13u64);
let debug_index=100000000;
let mut m=Market::new(); // USD type is 1, EUR type is 2, BTC type is 10, ETH type is 11, SOL type is 12
let teppy=m.register_trader("Teppy");
let luni =m.register_trader("Luni");
let usd =m.register_asset("USD");
let btc =m.register_asset("BTC");
m.add_trader_balance(teppy,btc,100000.into());
m.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);
if rng.gen_bool(0.5) {
sell_type=btc;
buy_type=usd;
sell_qty=rng.gen_range(1..=5).into();
buy_qty=sell_qty*rng.gen_range(60..=70).into();
} else {
sell_type=usd;
buy_type=btc;
buy_qty=rng.gen_range(1..=5).into();
sell_qty=buy_qty*rng.gen_range(60..=70).into();
}
let mut success=false;
if m.make_offer(seller,sell_type,buy_type,sell_qty,buy_qty) { count+=1; success=true; };
// println!("{} selling {} {} to buy {} {}, {}",seller,sell_qty,m.number_to_name(sell_type),buy_qty,m.number_to_name(buy_type),if success { "success" } else { "failure" });
if count>=1000000 { break; }
tries+=1;
}
println!("Tries: {} Trades: {}",tries,count);
// m.dump();
m.sanity_check();
}
let args: Vec<String> = env::args().collect();
let mode=if args.len()<=1 { "--exercise" } else { args[1].as_str() };
let mut m=Market::new(); // USD type is 1, EUR type is 2, BTC type is 10, ETH type is 11, SOL type is 12
match mode {
"--exercise" => m.exercise(),
"--treestuff" => tree_stuff(),
_ => println!("Unknown mode: {}",mode),
}
}