[research/lotterysim] replace apy with apr

script/research/lotterysim/acc_vs_staked_ratio.py

@@ -26,7 +26,7 @@ for portion in range(1,11):
         dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=0.005999999999989028, ki=-0.005999999985257798, kd=0.01299999999999478)
         for darkie in darkies:
             dt.add_darkie(darkie)
-        acc, apy, reward, staked_ratio, apr = dt.background_with_apy(rand_running_time=False)
+        acc, apy, reward, staked_ratio, apr = dt.background(rand_running_time=False)
         accs += [acc]
     avg_acc = sum(accs)/EXPS*100
     plot+=[(stake_portion, avg_acc)]

script/research/lotterysim/core/constants.py

@@ -12,14 +12,14 @@ F_MIN = 0.0001
 F_MAX = 0.9999
 
 REWARD_MIN = 0
-REWARD_MAX = 1000
+REWARD_MAX = 100
 
 SLOT = 90
 ONE_YEAR = Num(365.25*24*60*60/SLOT)
 
-TARGET_APY = Num(1)
+TARGET_APR = Num(1)
 
-PRIMARY_REWARD_TARGET = 0.33 # ratio of staked tokens
+PRIMARY_REWARD_TARGET = 0.5 # ratio of staked tokens
 SECONDARY_LEAD_TARGET = 1 #number of lead per slot
 
 EPSILON = 1

script/research/lotterysim/core/darkie.py

@@ -14,33 +14,20 @@ class Darkie():
         self.epoch_len=epoch_len # epoch length during which the stake is static
         self.strategy = strategy
         self.slot = 0
-        self.apys = []
 
     def clone(self):
         return Darkie(self.finalized_stake)
 
-    '''
-    def apy(self):
-        staked_tokens = self.staked_tokens()
-        apy = (Num(self.stake) - staked_tokens) / staked_tokens if self.stake>0 else 0
-        #print('stake: {}, staked_tokens: {}'.format(self.stake, staked_tokens))
-        return Num(apy)
-    '''
-
-    '''
-    @rewards: array of reward per epoch
-    return apy during runnigntime with compound interest
-    '''
     def apy_scaled_to_runningtime(self, rewards):
         avg_apy = 0
         for idx, reward in enumerate(rewards):
-            #print('slot: {}, idx: {} of {}, staked tokens: {}, initial stake: {}'.format(self.slot, idx, len(rewards), len(self.strategy.staked_tokens_ratio), len(self.initial_stake)))
             current_epoch_staked_tokens = Num(self.strategy.staked_tokens_ratio[idx-1]) * Num(self.initial_stake[idx-1])
             avg_apy += (Num(reward) / current_epoch_staked_tokens) if current_epoch_staked_tokens!=0 else 0
-        return avg_apy * Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot >0 else 0
+        return avg_apy * Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot  and self.initial_stake[0]>0 >0 else 0
+
 
     def apr_scaled_to_runningtime(self):
-        return Num(self.stake - self.initial_stake[0]) / Num(self.initial_stake[0]) *  Num(ONE_YEAR/(self.slot/EPOCH_LENGTH))
+        return Num(self.stake - self.initial_stake[0]) / Num(self.initial_stake[0]) *  Num(ONE_YEAR/(self.slot/EPOCH_LENGTH)) if self.slot> 0 and self.initial_stake[0]>0 else 0
 
     def staked_tokens(self):
         '''
@@ -64,7 +51,7 @@ class Darkie():
         self.slot = count
 
 
-    def run(self, rewards, hp=True):
+    def run(self, hp=True):
         k=N_TERM
         def target(tune_parameter, stake):
             x = (Num(1) if hp else 1)  - (Num(tune_parameter) if hp else tune_parameter)
@@ -74,10 +61,9 @@ class Darkie():
             return scaled_target
 
         if self.slot % EPOCH_LENGTH ==0 and self.slot > 0:
-            apy = self.apy_scaled_to_runningtime(rewards)
-            self.apys+=[apy]
+            apr = self.apr_scaled_to_runningtime()
             # staked ratio is added in strategy
-            self.strategy.set_ratio(self.slot, apy)
+            self.strategy.set_ratio(self.slot, apr)
             # epoch stake is added
             self.initial_stake +=[self.finalized_stake]
         T = target(self.f, self.strategy.staked_value(self.finalized_stake))
@@ -120,5 +106,3 @@ class Darkie():
             buf = 'initial stake:'+','.join([str(i) for i in self.initial_stake])
             buf += '\r\n'
             buf += 'staked ratio:'+','.join([str(i) for i in self.strategy.staked_tokens_ratio])
-            buf += 'apys: '+','.join([str(i) for i in self.apys])
-            f.write(buf)

script/research/lotterysim/core/lottery.py

@@ -20,7 +20,7 @@ class DarkfiTable:
     def add_darkie(self, darkie):
         self.darkies+=[darkie]
 
-    def background_with_apy(self, rand_running_time=True, debug=False, hp=True):
+    def background(self, rand_running_time=True, debug=False, hp=True):
         self.debug=debug
         self.start_time=time.time()
         feedback=0 # number leads in previous slot
@@ -45,7 +45,7 @@ class DarkfiTable:
             #note! thread overhead is 10X slower than sequential node execution!
             for i in range(len(self.darkies)):
                 self.darkies[i].set_sigma_feedback(self.Sigma, feedback, f, count, hp)
-                self.darkies[i].run(self.rewards, hp)
+                self.darkies[i].run(hp)
                 total_vesting_stake+=self.darkies[i].update_vesting()
 
 

script/research/lotterysim/core/strategy.py

@@ -5,7 +5,7 @@ class Strategy(object):
     def __init__(self, epoch_len=0):
         self.epoch_len = epoch_len
         self.staked_tokens_ratio = [1]
-        self.target_apy = TARGET_APY
+        self.target_apy = TARGET_APR
         self.type = 'base'
 
     def set_ratio(self, slot, apy):

script/research/lotterysim/discrete_instance.py

@@ -26,8 +26,8 @@ if __name__ == "__main__":
     dt = DarkfiTable(airdrop, RUNNING_TIME, CONTROLLER_TYPE_DISCRETE, kp=-0.010399999999938556, ki=-0.0365999996461878, kd=0.03840000000000491,  r_kp=-0.1345, r_ki=-0.5, r_kd=-0.5)
     for darkie in darkies:
         dt.add_darkie(darkie)
-    acc, avg_apy, avg_reward, stake_ratio, avg_apr = dt.background_with_apy(rand_running_time=False)
+    acc, avg_apy, avg_reward, stake_ratio, avg_apr = dt.background(rand_running_time=False)
     sum_zero_stake = sum([darkie.stake for darkie in darkies[NODES:]])
-    print('acc: {}, avg(apy): {}, avg(apr): {}, avg(reward): {}, stake_ratio: {}'.format(acc, avg_apy, avg_apr, avg_reward, stake_ratio))
+    print('acc: {}, avg(apr): {}, avg(reward): {}, stake_ratio: {}'.format(acc, avg_apr, avg_reward, stake_ratio))
     print('total stake of 0mint: {}, ration: {}'.format(sum_zero_stake, sum_zero_stake/ERC20DRK))
     dt.write()