def setPrice(self, demand):
#set new price depending on excess demand
newPrice = np.random.normal(df.getLastRow(self.stockPrice), 1)
df.appendNextRow(self.stockPrice, newPrice)
#adjust inventory
newInventory = df.getLastRow(self.stockInventory) + self.newIssue(
) #Incase we want to include issuance of additional shares inter period
df.appendNextRow(self.stockInventory, newInventory)
def updateRecords(self, demand_i, W_t):
investedWealth = np.array(demand_i) * np.array(
(self.marketMaker.stockPrice.iloc[-1]))
unInvestedWealth = W_t - np.sum(investedWealth)
value = df.getLastRow(self.stockValue) / 0.02
netDemand = df.getLastRow(self.numberofshares) - df.getPenultimateRow(
self.numberofshares)
df.appendNextRow(self.numberofshares, demand_i)
df.appendNextRow(self.excessDemand, netDemand)
df.appendNextRow(self.stockValue, value)
self.cashAccount.append(unInvestedWealth)
self.balanceSheet.append(W_t)
def passiveTrader(self):
t = int(self.clock.time() * 1 / self.clock.dt)
tau = np.int(self.rebalancingPeriod *
np.floor(t / self.rebalancingPeriod))
#Where W_i_t is the wealth invested in asset i at time t
#W_t is the total wealth at time t comprising of the sum of wealth invested in all individual assets plus
# wealth in bonds plus interest on bonds and new wealth introduced at time t
W_i_t = [
self.numberofshares[tickerID].values[-1] *
self.stockPrice[tickerID].values[-1]
for tickerID in self.stockPrice.columns
]
div_i_t = [
self.numberofshares[tickerID].values[-1] *
self.marketMaker.assets[x].computeDividend()
for x, tickerID in enumerate(self.stockPrice.columns)
]
df.appendNextRow(self.dividend, div_i_t)
div_t = np.sum(div_i_t)
W_t = (self.balanceSheet[-1]) + self.cashAccount[-1] * (
1 + self.marketMaker.riskFreeRate) + (self.cashFlow[-1]) + (div_t)
cashFlow_t = np.float(np.random.normal(0, 0))
self.cashFlow.append(cashFlow_t)
#We derive the market capital of each stock
marketCapital_i = df.getLastRow(self.marketMaker.marketCapital)
signal_i = [
tickerID / np.sum(marketCapital_i) for tickerID in marketCapital_i
]
#n stock world, investor picking one stock with highest signal;
demand_i = self.computeDemand(signal_i, W_t, self.cashFlow[-1], div_t,
t, tau)
self.updateRecords(demand_i, W_t)
return np.array(demand_i)
def receiveOrders(self, demand):
df.appendNextRow(self.marketCapital,
(demand * df.getLastRow(self.stockPrice)))
self.setPrice(demand)
def demandMethod(self, argument, signal_i, wealth, cashFlow, div, t, tau):
#print(signal_i)
demand = []
if (argument <= 1):
#Maarten's Algorithm
demand = [self.leverage * wealth * (np.tanh(signal_i) + 0.5)]
elif (argument == 2):
for x, tickerID in enumerate(self.numberofshares.columns):
if (x < 1):
if (t == tau):
d1 = np.sign(
signal_i[0]) * self.leverage * 0.6 * wealth * (
1 / df.getColumn(tickerID, self.stockPrice,
False).values[tau]
) * (1 /
(1 +
np.exp(-(signal_i[0]**2 - signal_i[1]**2))))
d2 = np.sign(
signal_i[1]
) * self.leverage * 0.6 * wealth * (1 / df.getColumn(
tickerID, self.stockPrice, False).values[tau]) * (
1 -
(1 /
(1 +
np.exp(-(signal_i[0]**2 - signal_i[1]**2)))))
else:
d1 = np.sign(signal_i[0]) * self.leverage * 0.6 * (
cashFlow + div) * (1 / df.getColumn(
tickerID, self.stockPrice,
False).values[t]) * (1 / (1 + np.exp(
-(signal_i[0]**2 - signal_i[1]**2)))) + (
df.getLastRow(self.numberofshares)[0])
d2 = np.sign(
signal_i[1]
) * self.leverage * 0.6 * cashFlow * (
1 / df.getColumn(tickerID, self.stockPrice,
False).values[t]
) * (1 -
(1 /
(1 + np.exp(-(signal_i[0]**2 - signal_i[1]**2))))
) + (df.getLastRow(self.numberofshares)[1])
demand.append(d1)
demand.append(d2)
else:
print('Code not yet implemented')
# #n stock world, investor picking one stock with highest signal;
#demand_i = []
# for x,tickerID in enumerate(self.numberofshares.columns):
# if (t==tau):
# #given we only invest in the stock that shows the maximum signal
# if np.abs(signalVT_i[x]) == max(
# np.abs(signalVT_i)):
# d = np.sign(
# signalVT_i[x]) * self.leverage * W_t * (
# np.tanh(signalVT_i[x]+np.log(2)))/self.stockPrice[tickerID].values[t]
# else:
# d = 0
# else:
# if np.abs(
# signalVT_i[x]) == max(np.abs(signalVT_i)):
# d = np.sign(
# signalVT_i[x]) * self.leverage * self.cashFlow[-1] * (
# np.tanh(signalVT_i[x]+np.log(2)))/self.stockPrice[tickerID].values[t]
# else:
# d = 0
# demand_i.append(d)
return demand