def __init__(self, start, underlyings):
myScheduler = Scheduler()
myDelays = []
freqs = ['3M', '6M', '1Y', '3Y']
for i in range(0, len(freqs)):
myDelays.append(myScheduler.extractDelay(freqs[i]))
AAA = {}
for i in range(0, len(freqs)):
vas = MC_Vasicek_Sim(x=AAAx[freqs[i]],
datelist=[start, myDelays[i] + start],
t_step=1 / 365.,
simNumber=500)
AAA[freqs[i]] = vas.getLibor()[0].loc[myDelays[i] + start]
BBB = {
'3M':
MC_Vasicek_Sim(x=BBBx[freqs[0]],
datelist=[start, myDelays[0] + start],
t_step=1 / 365.,
simNumber=500).getLibor()[0].loc[myDelays[0] +
start]
}
self.probs = {'AAA': AAA, 'BBB': BBB}
self.underlyings = underlyings
def __init__(self, K1, K2, Fs, Rs, betas, start_dates, end_dates, freqs,
coupons, referenceDates, ratings, bootstrap):
self.bootstrap = bootstrap
self.K1 = K1
self.K2 = K2
self.Fs = Fs
self.Rs = Rs
self.betas = betas
self.referenceDates = referenceDates
self.freqs = freqs
self.coupons = coupons
self.start_dates = start_dates
self.end_dates = end_dates
self.ratings = ratings
self.R = Rs[0]
self.beta = betas[0]
self.referenceDate = referenceDates[0]
self.freq = freqs[0]
self.coupon = coupons[0]
self.start_date = start_dates[0]
self.end_date = end_dates[0]
self.rating = ratings[0]
self.maturity = end_dates[0]
self.myScheduler = Scheduler()
def __init__(self,
fee,
coupon,
start,
maturity,
freq,
referencedate,
observationdate,
rating,
notional=1,
recovery=0.4):
self.numSim = 10
self.t_step = 1.0 / 365
self.fee = fee
self.coupon = coupon
self.start = start
self.maturity = maturity
self.freq = freq
self.recovery = recovery
self.rating = rating
self.referencedate = referencedate
self.observationdate = observationdate
self.myScheduler = Scheduler()
self.delay = self.myScheduler.extractDelay(freq=freq)
self.referencedate = referencedate
self.getScheduleComplete()
self.fullDateList = self.datelist
self.ntimes = len(self.datelist)
self.pvAvg = 0.0
self.cashFlows = DataFrame()
self.cashFlowsAvg = []
self.yieldIn = 0.0
self.notional = notional
self.errorCurve = []
self.mcSim = MC_Vasicek_Sim()
def test_calculate_tracks(self):
input_data = SchedulerApp.process_input(
'ConferencetrackmanagementPythonGA/tests/test_input2.txt')
my_scheduler = Scheduler()
times = my_scheduler.calculate_times(input_data)
self.assertEquals(my_scheduler.calculate_tracks(times), ({
0: ('talk12 60min', 60),
120: ('talk14 60min', 60),
60: ('talk13 60min', 60)
}, {
0: ('talk8 60min', 60),
120: ('talk10 60min', 60),
180: ('talk11 60min', 60),
60: ('talk9 60min', 60)
}, {
0: ('talk5 60min', 60),
120: ('talk7 60min', 60),
60: ('talk6 60min', 60)
}, {
0: ('talk1 60min', 60),
120: ('talk3 60min', 60),
180: ('talk4 60min', 60),
60: ('talk2 60min', 60)
}, 0))
input_data = SchedulerApp.process_input(
'ConferencetrackmanagementPythonGA/tests/test_input3.txt')
my_scheduler = Scheduler()
times = my_scheduler.calculate_times(input_data)
self.assertEquals(my_scheduler.calculate_tracks(times), ({
0: ('talk12 60min', 60),
120: ('talk14 60min', 60),
60: ('talk13 60min', 60)
}, {
0: ('talk8 60min', 60),
120: ('talk10 60min', 60),
180: ('talk11 60min', 60),
60: ('talk9 60min', 60)
}, {
0: ('talk5 60min', 60),
120: ('talk7 60min', 60),
60: ('talk6 60min', 60)
}, {
0: ('talk1 60min', 60),
120: ('talk3 60min', 60),
180: ('talk4 60min', 60),
60: ('talk2 60min', 60)
}, 1))
def getScheduleComplete(self):
myscheduler = Scheduler()
self.datelist = myscheduler.getSchedule(self.start, self.maturity,
self.freq, self.start)
self.ntimes = len(self.datelist)
fullset = sorted(
set(self.datelist).union([self.start]).union([self.maturity]))
return fullset, self.datelist
def __init__(self, memory, file_system, clock):
self.file_system = file_system(Disc())
self.memory_admin = MemoryAdmin(AsignacionContinua(memory))
self.pid = 0
self.scheduler = Scheduler()
self.cpu = Cpu(self)
self.pcb_table = PCBTable()
self.clock = clock
def test_calculate_times(self):
input_data = SchedulerApp.process_input(
'ConferencetrackmanagementPythonGA/tests/test_input.txt')
my_scheduler = Scheduler()
self.assertEquals(my_scheduler.calculate_times(input_data),
[('talk2 60min', 60), ('talk3 45min', 45),
('talk5 30min', 30), ('talk1 25min', 25),
('talk4 lightning', 5)])
def __init__(self):
self.OIS = []
self.filename = WORKING_DIR + '/CorpData.dat'
self.corporates = []
self.ratings = ['AAA', 'AA', 'A', 'BBB', 'BB', 'B', 'CCC']
self.corpSpreads = {}
self.corporates = pd.DataFrame()
self.tenors = []
self.unPickleMe(file=self.filename)
self.myScheduler=Scheduler()
def __init__(self):
self.OIS = []
self.filename = WORKING_DIR + '/CorpData.dat'
self.corporates = []
self.ratings = ['AAA', 'AA', 'A', 'BBB', 'BB', 'B', 'CCC']
self.corpSpreads = {}
self.corporates = pd.DataFrame()
self.tenors = []
self.unPickleMe(file=self.filename)
self.myScheduler = Scheduler(start=trim_start,
end=trim_end,
freq=freq,
reference=referenceDate)
def __init__(self, option_start, cds_start,cds_end,strike,cds_freq,cds_flavor,cds_recovery,Q):
self.option_start = option_start
self.strike = strike
self.cds_start = cds_start
self.cds_end = cds_end
self.cds_freq = cds_freq
# payer to pay strike K, spread - k; receiver to receive strike K, k - spread
self.cds_flavor = cds_flavor
self.cds_recovery = cds_recovery
self.myScheduler = Scheduler()
self.cds_datelist = self.myScheduler.getSchedule(self.cds_start,self.cds_end,self.cds_freq,self.cds_start)
self.OIS = OIS(option_start,cds_end)
self.Q = Q
self.ntimes = np.shape(self.Q)[0]
self.ntrajectories = np.shape(self.Q)[1]
def setCIR(self, minDay, maxDay, x, simNumber, t_step):
# dλ(t) = k(θ − λ(t))dt + σ*sqrt(λ(t))*dW(t)
self.kappa = x[0]
self.theta = x[1]
self.sigma = x[2]
self.r0 = x[3]
self.simNumber = simNumber
self.t_step = t_step
# creation of a fine grid for Monte Carlo integration
# Create fine date grid for SDE integration
self.Schedule = Scheduler()
self.datelistlong = self.Schedule.getSchedule(start=minDay,end=maxDay,freq="1M",referencedate=minDay)
self.datelistlong_daily = pd.date_range(minDay, maxDay).tolist()
self.datelistlong_daily = [x.date() for x in self.datelistlong_daily]
self.ntimes = len(self.datelistlong)
self.ntimes_daily = len(self.datelistlong_daily)
self.survival = []
self.smallSurvival = []
def __init__(self, fee, start,coupon, maturity, freq, referencedate, observationdate,notional):
self.fee = fee
self.coupon=coupon
self.start = start
self.maturity = maturity
self.freq= freq
self.referencedate = referencedate
self.observationdate = observationdate
self.myScheduler = Scheduler()
self.delay = self.myScheduler.extractDelay(freq=freq)
self.getScheduleComplete()
self.ntimes=len(self.datelist)
self.referencedate = referencedate
self.pvAvg=0.0
self.cashFlows = DataFrame()
self.cashFlowsAvg = []
self.yieldIn = 0.0
self.notional=notional
def __init__(self):
self.OIS = []
self.filename = WORKING_DIR + '/CorpData.dat'
self.corporates = []
self.ratings = {
'AAA': "BAMLC0A1CAAA",
'AA': "BAMLC0A2CAA",
'A': "BAMLC0A3CA",
'BBB': "BAMLC0A4CBBB",
'BB': "BAMLH0A1HYBB",
'B': "BAMLH0A2HYB",
'CCC': "BAMLH0A3HYC"
}
self.corpSpreads = {}
self.corporates = pd.DataFrame()
self.Qcorporates = pd.DataFrame() # survival function for corporates
self.tenors = []
self.unPickleMe(file=self.filename)
self.myScheduler = Scheduler()
self.myVasicek = MC_Vasicek_Sim()
self.R = 0.4
def __init__(self,
start_date,
end_date,
freq,
coupon,
referenceDate,
rating,
R=.4):
### Parameters passed to external functions
self.start_date = start_date
self.end_date = end_date
self.freq = freq
self.R = R
self.notional = 1
self.fee = fee
self.rating = rating
self.coupon = coupon
self.referenceDate = referenceDate
self.observationDate = referenceDate
## Get datelist ##
self.myScheduler = Scheduler()
# ReferenceDateList = self.myScheduler.getSchedule(start=referenceDate,end=end_date,freq=freq, referencedate=referenceDate)
## Delay start and maturity
delay = self.myScheduler.extractDelay(self.freq)
cashFlowDays = self.myScheduler.extractDelay("3M")
## Delay maturity and start date
# self.start_date = self.start_date +SixMonthDelay
# self.maturity =self.start_date + delay
self.maturity = self.start_date + delay
fulllist, datelist = self.getScheduleComplete()
self.datelist = datelist
self.portfolioScheduleOfCF = fulllist
self.myZ = None
self.myQ = None
def __init__(self,
startDate,
endDate,
referenceDate,
effectiveDate,
freq,
notional,
recovery=0.4):
"""
effective date is the start of the payments, startDate is when the contract is entered, endDate is maturity
referenceDate is the date when the PV is taken
We are paying a fixed rate to receive a floating rate
"""
self.recovery = recovery
self.simNum = 10
self.xR = []
self.xQ = []
# use MC to generate scenarios for exposure
self.mcSim = MC_Vasicek_Sim()
#self.mcSim.setVasicek(minDay=startDate,maxDay=endDate,x=xR,t_step=1.0/365, simNumber=self.simNum)
# z is discount curve
self.zCurve = []
self.swapRate = []
self.freq = freq
self.notional = notional
self.fixedLeg = []
self.floatingLeg = []
self.startDate = startDate
self.endDate = endDate
self.referenceDate = referenceDate
self.effctiveDate = effectiveDate
self.initialSpread = []
self.myScheduler = Scheduler()
self.datelist = pd.date_range(start=effectiveDate,
end=endDate,
freq=freq)
__author__ = 'blee13'
from unittest import TestCase
from MonteCarloSimulators.Vasicek.vasicekMCSim import MC_Vasicek_Sim
from Products.Rates.CouponBond import CouponBond
from Curves.Corporates.CorporateDaily import CorporateRates
from Scheduler.Scheduler import Scheduler
import matplotlib.pyplot as plt
from Products.Credit.IRSwap import IRSwap
import pandas as pd
from datetime import date
myScheduler = Scheduler()
periods = '1Y'
freq = '1M'
t_step = 1.0 / 365.0
simNumber = 10
trim_start = date(2000, 1, 1)
trim_end = date(2000, 12, 31)
trim_endMC = date(2001, 12, 31)
effDay = date(2000, 4, 1)
referenceDate = date(2000, 1, 1)
testSched = pd.date_range(trim_start, trim_start)
scheduleComplete = pd.date_range(start=trim_start, end=trim_end)
xR = [3.0, 0.05, 0.04, 0.03]
datelist = myScheduler.getSchedule(start=trim_start,
end=trim_end,
freq=freq,
referencedate=referenceDate)
myMC = MC_Vasicek_Sim()
myMC.setVasicek(x=xR,
minDay=trim_start,
# Method used to read the input_data
def process_input(input_path_var):
with open(input_path_var, 'r') as f:
read_data = f.read()
return read_data.split(', ')
# Method called to do a 'clear', just for application visualization purposes
def clean_screen():
print(chr(27) + "[2J")
if __name__ == '__main__':
clean_screen()
presentation()
if len(sys.argv) == 1:
input_path = 'ConferencetrackmanagementPythonGA/data/input.txt'
else:
input_path = sys.argv[1]
input_data = process_input(input_path)
my_scheduler = Scheduler()
times = my_scheduler.calculate_times(input_data)
track1morning, track1afternoon, track2morning, track2afternoon, left_sessions = Scheduler.calculate_tracks(
times)
Printer.show_tracks(track1morning, track1afternoon, track2morning,
track2afternoon)
def fitModel2Curve(self, x):
results = minimize(fun=self.fCurve, x0=x)
return results.x
def fCurve(self, x):
calCurve = self.getLiborAvg(x, self.datelist)
thisPV = np.multiple(self.cashFlows,
calcCurve).mean(axis=1).sum(axis=0)
error = 1e4 * (self.price - thisPV)**2
return
if (__name__ == "__main__"):
coupon = 0.03
myscheduler = Scheduler()
datelist = myscheduler(start=trim_start,
end=trim_end,
freq="3M",
referencedate=trim_start)
myMC = MC_Vasicek_Sim(x=XR,
datelist=datelist,
simNumber=simnumber,
t_step=t_step)
libor = myMC.getSmallLibor(datelist=datelist)
myBond = Bond(libor=libor,
start=trim_start,
maturity=trim_end,
coupon=coupon,
freq="3M",
referencedate=trim_start)
from unittest import TestCase
from parameters import xR, simNumber, t_step, trim_start, trim_end, freq, periods, referenceDate, start, inArrears, WORKING_DIR
from MonteCarloSimulators.Vasicek.vasicekMCSim import MC_Vasicek_Sim
from Scheduler.Scheduler import Scheduler
mySchedule = Scheduler()
# Global Variables
mySchedule = mySchedule.getSchedule(start=trim_start, end=trim_end, freq="M")
mySimulator = MC_Vasicek_Sim(datelist=mySchedule,
x=xR,
simNumber=simNumber,
t_step=t_step)
mySimulator.getLibor()
mySimulator.getSmallLibor()
a = 1
class TestMC_Vasicek_Sim(TestCase):
def test_getLibor(self):
mySimulator.getLibor()
def test_getSmallLibor(self):
# Monte Carlo trajectories creation - R
Libor = mySimulator.getSmallLibor(mySchedule)
return Libor
self.OIS = self.OIS.fillna(method='ffill').fillna(method='bfill')
self.OIS = self.OIS.T.fillna(method='ffill').fillna(method='bfill').T
self.OIS.index = self.datesAll.DATE
def getOIS(self, datelist=[]):
if (len(datelist) != 0):
return self.OIS.loc[datelist]
else:
return self.OIS
if (__name__ == "__main__"):
import quandl
from parameters import WORKING_DIR, x0Vas, t_step, simNumber, trim_start, trim_end, freq, referenceDate
#a = quandl.get("USTREASURY/YIELD", authtoken="J_3ufFECZVffPxNDZuWf", trim_start="2016-01-10", trim_end="2017-01-10")
from Scheduler.Scheduler2 import Scheduler
import pandas as pd
import numpy as np
mydatelist = Scheduler(start=trim_start,
end=trim_end,
freq=freq,
reference=referenceDate).datelist1
mycr = CorporateRates()
bb = mycr.getCorporates(trim_start, trim_end)
myois = OIS()
aa = myois.getOIS(mydatelist)
print(bb)
