def build_scenset_with_model(model,
refdate=None,
set_name='set_name1',
scen_name='scen_name1',
result_name='result_name1'):
scen_set = xen.ScenarioSet(set_name)
scen1 = xen.Scenario(scen_name, result_name)
_refdate = refdate
if refdate is None:
_refdate = xen_u.datetime_to_datestr_yyyymmdd(datetime.datetime.now())
scen1.general.reference_date = _refdate
# model type check
if type(model) is list:
for m in model:
scen1.add_model(m)
scen1.refresh_corr()
else:
scen1.add_model(model)
scen_set.add_scenario(scen1)
return scen_set
def test(model):
scen1 = scen.Scenario()
scen1.add_model(model)
scen1.refresh_corr()
scen1.save_as('heston_test')
scen1.generate('heston_test', 'heston_result')
def build_test_scen_set():
test_scen_set = xen.ScenarioSet('test_scen_set')
scen1 = xen.Scenario('scen1', 'result1')
scen1.add_model(xen_s.gbm('test_gbm'))
test_scen_set.add_scenario(scen1)
return test_scen_set
def test():
model = scen.GarmanKohlhagen('gk_model')
scen1 = scen.Scenario()
scen1.add_model(model)
scen1.save_as('gk_test')
scen1.generate('gk_test', 'gk_result')
def test(model):
calibration_tools = dict()
calibration_tools['cap1'] = scen.CapTool('cap1')
calibration_tools['cap1'].sections['DISCOUNT_CURVE_VALUE'] = [0.03, 0.031, 0.032, 0.033]
calibration_tools['cap1'].sections['DISCOUNT_CURVE_TENOR'] = ['1Y', '2Y', '3Y', '4Y']
calibration_tools['cap1'].sections['DISCOUNT_CURVE_INTERPOLATION'] = 'MONOTONICCUBICNATURALSPLINE'
calibration_tools['cap1'].sections['CAP_VOL_CURVE_VALUE'] = [0.155, 0.160, 0.158, 0.156]
calibration_tools['cap1'].sections['CAP_VOL_CURVE_TENOR'] = ['12M', '24M', '36M', '48M']
calibration_tools['cap1'].sections['CAP_VOL_CURVE_STRIKE'] = 0.03
calibration_tools['cap1'].sections['REF_INDEX'] = 'IRSKRW'
cali1 = scen.Calibrator()
cali1.model = model
cali1.calibrationtools = calibration_tools
cali1.save_as(cali_id)
# cali1.calibrate('testcali1')
scen1 = scen.Scenario()
scen1.add_model(model)
scen1.save_as('vasicek1f_test')
scen1.generate('vasicek1f_test', 'vasicek1f_result')
def equity(model,
scenario_num=1000,
maxyear=3,
moment_match=False,
frequency=xen.TimeGridFrequency.Day):
if not isinstance(model, xen.Eq1FModel):
raise Exception('Eq1FModel Type is needed')
scenSetID = 'test_set'
scenID = 'equity_test_scen'
resultID = 'equity_test_result'
scenSet = xen.ScenarioSet(scenSetID)
scen = xen.Scenario(scenID, resultID)
scen.general.maxyear = maxyear
scen.general.scenario_num = scenario_num
scen.general.moment_match = moment_match
scen.general.frequency = frequency
# setting additional calculation for martinagle test
model.clear_calc()
calc_randomZ = xen_c.RandomZ()
model.add_calc(calc_randomZ)
calc_uncon_expectation = xen_c.UnconditionalExpectation()
model.add_calc(calc_uncon_expectation)
scen.add_model(model)
scenSet.add_scenario(scen)
scenSet.generate()
res = xen_r.ResultObj(scenSetID, scenID, resultID)
equity = res.get_resultModel(model=model)
equity_uncon_expectation = res.get_resultModel(model=model,
calc=calc_uncon_expectation)
rnd_z = res.get_resultModel(model=model, calc=calc_randomZ)
plt.figure(1)
plt.plot(res.timegrid.data['T'], equity.average(), label='equity_aver')
plt.plot(res.timegrid.data['T'],
equity_uncon_expectation.data[0],
label='equity_analytic')
plt.title('equity_aver vs equity_analytic')
plt.xlabel('time (year)')
plt.ylabel('value')
plt.legend()
plt.figure(2)
plt.title('rand_z')
plt.plot(rnd_z.average())
plt.show()
def do_test():
scenSet = xen.ScenarioSet('set1')
model = get_test_model('bm_model')
scen1 = xen.Scenario('scen1', 'testResult')
scen1.add_model(model)
scen1.general.scenario_num = 100
scen1.general.maxyear = 5
scen1.general.frequency = xen.TimeGridFrequency.Day
#print scen1.dump()
scenSet.add_scenario(scen1)
scenSet.generate_test()
xen_v.plot_all(scenSet)
def eq_up_out_call():
scen_set = xen.ScenarioSet('test_set')
scen = xen.Scenario('eq_multi', 'pricing1')
model_eq1 = xen_s.gbmconst('eq1')
model_eq2 = xen_s.gbmconst('eq2')
scen.add_model(model_eq1)
scen.add_model(model_eq2)
scen.refresh_corr()
scen_set.add_scenario(scen)
scen_set.generate()
def rw_shortrate(model,
scenario_num=200,
maxyear=3,
moment_match=False,
frequency=xen.TimeGridFrequency.Day):
if not isinstance(model, xen.Ir1FModel):
raise Exception('Ir1FModel Type is needed')
scenSetID = 'test_set'
scenID = 'test_scen'
resultID = 'test_result_' + model.model_name
scenSet = xen.ScenarioSet(scenSetID)
scen = xen.Scenario(scenID, resultID)
scen.general.maxyear = maxyear
scen.general.scenario_num = scenario_num
scen.general.moment_match = moment_match
scen.general.frequency = frequency
# setting additional calculation for martinagle test
model.clear_calc()
# calc_randomZ = xen_c.RandomZ()
# model.add_calc(calc_randomZ)
calc_uncon_expectation = xen_c.UnconditionalExpectation()
model.add_calc(calc_uncon_expectation)
scen.add_model(model)
scenSet.add_scenario(scen)
scenSet.generate()
res = xen_r.ResultObj(scenSetID, scenID, resultID)
shortrate = res.get_resultModel(model=model)
shortrate_uncon_expectation = res.get_resultModel(
model=model, calc=calc_uncon_expectation)
#rnd_z = res.get_resultModel(model=model, calc=calc_randomZ)
i = 0
plt.figure(1)
plt.plot(res.timegrid.data['T'], shortrate.average(), label='shor_aver')
plt.plot(res.timegrid.data['T'],
shortrate_uncon_expectation.data[0],
label='short_analytic')
plt.title('short_aver vs short_analytic')
plt.xlabel('time (year)')
plt.ylabel('rate (%)')
plt.legend()
plt.figure(2)
plt.plot(res.timegrid.data['T'],
shortrate.average() - shortrate_uncon_expectation.data[0],
label='diff')
plt.title('short_aver - short_analytic')
plt.xlabel('time (year)')
plt.ylabel('rate (%)')
plt.legend()
# plt.figure(3)
# plt.title('rand_z')
# plt.plot(rnd_z.average())
#print('aver Z : ' + rnd_z))
plt.show()
# coding=euc-kr
import xenarix as scen
from xenarix import martingale as mart
import test.model.all_test as test_model
scen_id = 'testallmodel_1'
result_id = 'testresult_1'
set_name = 'setname_1'
set1 = scen.ScenarioSet(set_name)
scen1 = scen.Scenario(scen_id, result_id)
scen1.general.scenario_num = 200
scen1.general.maxyear = 30
scen1.general.rnd_seed = 16
scen1.general.frequency = 'MONTH'
scen1.general.rnd_type = 'SOBOL'
gbm = test_model.gbm.get_test_model('gbm_test')
gbmconst = test_model.gbmconst.get_test_model('gbmconst_test')
gk = test_model.gk.get_test_model('gk_test')
hw1f = test_model.hw1f.get_test_model('hw1f_test')
bk1f = test_model.bk1f.get_test_model('bk1f_test')
cir1f = test_model.cir1f.get_test_model('cir1f_test')
cir1fext = test_model.cir1fext.get_test_model('cir1fext_test')
vasicek = test_model.vasicek.get_test_model('vasicek_test')
heston = test_model.heston.get_test_model('heston_test')
# scen1.add_model(gbmconst) #
# scen1.add_model(gbm) # const에 비해 vol때매 좀 느림
def test(model):
scen1 = scen.Scenario()
scen1.add_model(model)
scen1.save_as('gbm_test')
scen1.generate('gbm_test', 'gbm_result')
def shortrate(model,
scenario_num=1000,
maxyear=3,
moment_match=False,
frequency=xen.TimeGridFrequency.Day):
if not isinstance(model, xen.Ir1FModel):
raise Exception('Ir1FModel Type is needed')
scenSetID = 'test_shortratecalc_set'
scenID = 'test_shortratecalc_scen'
resultID = 'test_shortratecalc_result'
scenSet = xen.ScenarioSet(scenSetID)
scen = xen.Scenario(scenID, resultID)
scen.general.maxyear = maxyear
scen.general.scenario_num = scenario_num
scen.general.moment_match = moment_match
scen.general.frequency = frequency
model.clear_calc()
# spot ----------------------------------------------
calc_spot3M = xen_c.Spot('test_spot3m')
calc_spot3M.maturity = '3M'
model.add_calc(calc_spot3M)
calc_spot6M = xen_c.Spot('test_spot6m')
calc_spot6M.maturity = '6M'
model.add_calc(calc_spot6M)
calc_spot24M = xen_c.Spot('test_spot24m')
calc_spot24M.maturity = '24M'
model.add_calc(calc_spot24M)
# forward ----------------------------------------------
calc_forward_1M = xen_c.Forward('test_forward1m')
calc_forward_1M.maturity = '1M'
model.add_calc(calc_forward_1M)
calc_forward_1Y_1M = xen_c.Forward('test_forward1y_1m')
calc_forward_1Y_1M.forward_peoriod = '1Y'
calc_forward_1Y_1M.maturity = '1M'
model.add_calc(calc_forward_1Y_1M)
calc_forward_1Y = xen_c.Forward('test_forward1y')
calc_forward_1Y.maturity = '1Y'
model.add_calc(calc_forward_1Y)
calc_forward_1Y_1Y = xen_c.Forward('test_forward1y_1y')
calc_forward_1Y_1Y.forward_peoriod = '1Y'
calc_forward_1Y_1Y.maturity = '1Y'
model.add_calc(calc_forward_1Y_1Y)
# calc_cmt = xen_c.CMT('test_cmt')
# model.add_calc(calc_cmt)
#
# calc_zerobond = xen_c.ZeroBond('test_zb')
# model.add_calc(calc_zerobond)
scen.add_model(model)
scenSet.add_scenario(scen)
scenSet.generate()
res = xen_r.ResultObj(scenSetID, scenID, resultID)
shortrate = res.get_resultModel(model=model)
rm_calc_spot3M = res.get_resultModel(model=model, calc=calc_spot3M)
rm_calc_spot6M = res.get_resultModel(model=model, calc=calc_spot6M)
rm_calc_spot24M = res.get_resultModel(model=model, calc=calc_spot24M)
# rm_calc_ = res.get_resultModel(model=model, calc=calc_zerobond)
# rm_calc_cmt = res.get_resultModel(model=model, calc=calc_cmt)
# rm_calc_zerobond = res.get_resultModel(model=model, calc=calc_zerobond)
# plt.plot(shortrate_aver)
# plt.plot(shortrate_uncon_expectation[0])
plt.figure(1)
plt.plot(res.timegrid.data['T'], shortrate.average(), label='shor_aver')
plt.plot(res.timegrid.data['T'], rm_calc_spot3M.average(), label='spot_3m')
plt.plot(res.timegrid.data['T'], rm_calc_spot6M.average(), label='spot_6m')
plt.plot(res.timegrid.data['T'],
rm_calc_spot24M.average(),
label='spot_24m')
plt.title('short_aver vs cmt_aver vs zerobond_aver')
plt.xlabel('time (year)')
plt.ylabel('rate (%)')
plt.show()
# assumption
total_remittance_amount = 30000000000 # 30억 (월간)
remittance_marketshare_ratio = 0.3
remi_issue_amount = 11500000000 # 115억개
remi_circulation_amount = 5000000000 # 50억개
remittance_fee = 0.015
dividend_ratio = 0.7
IEO_price = 1
market_capitalization = remi_circulation_amount * IEO_price
rf = 0.015
per = 0.05
# generation setting - simulation part
scen_set = xen.ScenarioSet('test')
scen = xen.Scenario(scen_id='testid', result_id='resultid')
gbm = xen_s.gbmconst(process_name='trm')
gbm.x0 = 30
scen.add_model(gbm)
scen.general.frequency = xen.TimeGridFrequency.EndOfMonth
scen.general.maxyear = 5
scen.general.scenario_num = 500
scen_set.add_scenario(scen)
scen_set.generate()
total_profit = 0
total_discounted_profit = 0
# 1년간만 뿌림
for month in range(1, 12):
holder_profit = total_remittance_amount * remittance_marketshare_ratio * remittance_fee * dividend_ratio
total_profit += holder_profit
pass
class MartingaleTestReulst(TestResult):
def __init__(self):
TestResult.__init__()
self.evolve_values = None
self.expected_values = None
def set_scenario(self, scen):
result_list = results.xeResultList(set_name, scen.get_scen_id(),
scen.get_result_id())
set_name = 'validation_test'
scen1 = xen.Scenario('test', 'test1')
# scenario를 받어서 거기 안에 들어있는거 전부?
# set_name을 martinagle_test 라고함?
def test_scenario_validation(scen):
# 필요한 caluculation을 넣음
for model in scen.models.values():
#model.add_debug_calc('EXPECTATION')
model.add_calc(xen.UnconditionalExpectation())
#model.add_calc(xen.Expectation())
model.add_calc(xen.RandomZ())
model.add_calc(xen.Drift())
# model.add_calc('FITTINGDISCOUNT')
# coding=euc-kr
from test import bk1f_test, test as cir1f_test, test as cir1fext_test, test as hw1f_test, test as vasicek_test, \
test as gbm_test, test as gbmconst_test
# import gbmlocalvol_test
# import cev_test
# import cevconst_test
# import cevlocalvol_test
import xenarix as scen
scen1 = scen.Scenario()
scen1.general.sections["SCENARIO_NUM"] = 30
# ir
scen1.add_model(bk1f_test.get_test_model('bk1f_test'))
scen1.add_model(cir1f_test.get_test_model('cir1f_test'))
scen1.add_model(cir1fext_test.get_test_model('cir1fext_test'))
scen1.add_model(hw1f_test.get_test_model('hw1f_test'))
#scen1.add_model(g2ext_test.get_test_model('g2ext_test'))
scen1.add_model(vasicek_test.get_test_model('vasicek_test'))
# eq
scen1.add_model(gbm_test.get_test_model('gbm_test'))
scen1.add_model(gbmconst_test.get_test_model('gbmconst_test'))
#scen1.add_model(gbmlocalvol_test.get_test_model('gbmlocalvol_test'))
scen1.add_model(cev_test.get_test_model('cev_test'))
scen1.add_model(cevconst_test.get_test_model('cevconst_test'))
#scen1.add_model(cevlocalvol_test.get_test_model('cevlocalvol_test'))
#scen1.add_model(heston_test.get_test_model('heston_test'))
import xenarix as xen
import xenarix.sample as xen_s
xen.set_repository('c:\\xenarix')
set_name = 'set1'
scenSet = xen.ScenarioSet(set_name=set_name)
scen_id = 'scen1'
result_id = 'res1'
scen1 = xen.Scenario(scen_id=scen_id, result_id=result_id)
scen1.general.scenario_num = 200
scen1.general.maxyear = 5
gbm1 = xen_s.gbmconst('kospi200')
gbm2 = xen_s.gbmconst('kospi200_2')
gbm3 = xen_s.gbmconst('kospi200_3')
scen1.add_model(gbm1)
scen1.add_model(gbm2)
scen1.add_model(gbm3)
scenSet.add_scenario(scen1)
scen1.refresh_corr()
scen1.set_corr(gbm1, gbm3, 0.3)
scen1.set_corr(gbm1, gbm2, 0.5)
# print(scen1.correlation.dump())
def build_test_scen_set():
test_scen_set = xen.ScenarioSet('test_scen_set')
scen_num = 1000
maxyear = 3
moment_match = False
rnd_seed = 10
rnd_skip = 4096 * 2
test_model = xen_s.gbm('test_gbm')
calc_uncon_expectation = xen_c.UnconditionalExpectation()
test_model.add_calc(calc_uncon_expectation)
# for crude
rnd_crude_subtype_list = [
xen.RndSubType.MersenneTwister, xen.RndSubType.Knuth,
xen.RndSubType.Lecuyer, xen.RndSubType.Ranlux3, xen.RndSubType.Ranlux4
]
for rnd_subtype in rnd_crude_subtype_list:
scen = xen.Scenario('scen1', rnd_subtype + '_result')
scen.general.scenario_num = scen_num
scen.general.maxyear = maxyear
scen.general.rnd_type = xen.RndType.Crude
scen.general.rnd_subtype = rnd_subtype
scen.general.rnd_seed = rnd_seed
scen.general.rnd_skip = rnd_skip
scen.general.moment_match = moment_match
scen.add_model(test_model)
test_scen_set.add_scenario(scen)
# for sobol
rnd_sobol_subtype_list = [
xen.RndSubType.Jaeckel, xen.RndSubType.SobolLevitan,
xen.RndSubType.SobolLevitanLemieux, xen.RndSubType.JoeKuoD5,
xen.RndSubType.JoeKuoD6, xen.RndSubType.JoeKuoD7, xen.RndSubType.Kuo,
xen.RndSubType.Kuo2, xen.RndSubType.Kuo3
]
for rnd_subtype in rnd_sobol_subtype_list:
scen = xen.Scenario('scen1', rnd_subtype + '_result')
scen.general.scenario_num = scen_num
scen.general.maxyear = maxyear
scen.general.rnd_type = xen.RndType.Sobol
scen.general.rnd_subtype = rnd_subtype
scen.general.rnd_seed = rnd_seed
scen.general.rnd_skip = rnd_skip
scen.general.moment_match = moment_match
scen.add_model(test_model)
test_scen_set.add_scenario(scen)
# for Halton
scen = xen.Scenario('scen1', xen_r.RndType.Halton + '_result')
scen.general.scenario_num = scen_num
scen.general.maxyear = maxyear
scen.general.rnd_type = xen.RndType.Halton
scen.general.moment_match = moment_match
scen.general.rnd_seed = rnd_seed
scen.general.rnd_skip = rnd_skip
scen.add_model(test_model)
test_scen_set.add_scenario(scen)
# for Faure
scen = xen.Scenario('scen1', xen_r.RndType.Faure + '_result')
scen.general.scenario_num = scen_num
scen.general.maxyear = maxyear
scen.general.rnd_type = xen.RndType.Faure
scen.general.moment_match = moment_match
scen.general.rnd_seed = rnd_seed
scen.general.rnd_skip = rnd_skip
scen.add_model(test_model)
test_scen_set.add_scenario(scen)
return test_scen_set
def test(model):
scen1 = scen.Scenario()
scen1.add_model(model)
scen1.save_as('cevlocalvol_test')
scen1.generate('cevlocalvol_test', 'cevlocalvol_result')
def mc_shortrate(model,
scenario_num=200,
maxyear=3,
moment_match=False,
frequency=xen.TimeGridFrequency.Day):
if not isinstance(model, xen.Ir1FModel):
raise Exception('Ir1FModel Type is needed')
scenSetID = 'test_set'
scenID = 'test_scen'
resultID = 'test_result_' + model.model_name
scenSet = xen.ScenarioSet(scenSetID)
scen = xen.Scenario(scenID, resultID)
scen.general.maxyear = maxyear
scen.general.scenario_num = scenario_num
scen.general.moment_match = moment_match
scen.general.frequency = frequency
# setting additional calculation for martinagle test
model.clear_calc()
# calc_randomZ = xen_c.RandomZ()
# model.add_calc(calc_randomZ)
calc_uncon_expectation = xen_c.UnconditionalExpectation()
model.add_calc(calc_uncon_expectation)
calc_mrk_discount = xen_c.FittingDiscount()
model.add_calc(calc_mrk_discount)
calc_model_discount = xen_c.ModelDiscount()
model.add_calc(calc_model_discount)
scen.add_model(model)
scenSet.add_scenario(scen)
scenSet.generate()
res = xen_r.ResultObj(scenSetID, scenID, resultID)
shortrate = res.get_resultModel(model=model)
shortrate_uncon_expectation = res.get_resultModel(
model=model, calc=calc_uncon_expectation)
mrk_discount = res.get_resultModel(model=model, calc=calc_mrk_discount)
model_discount = res.get_resultModel(model=model, calc=calc_model_discount)
#rnd_z = res.get_resultModel(model=model, calc=calc_randomZ)
print(mrk_discount.data[0])
# result_list['BASE_FITTINGDISCOUNT'].load(1, 1)
#
# shortrate_aver = result_list['BASE_nan'].averave()
# shortrate = result_list['BASE_nan'].load()
# shortrate_uncon_expectation = result_list['BASE_UNCONDITIONALEXPECTATION'].load()
# mrk_discount = result_list['BASE_FITTINGDISCOUNT'].load()
# discount = result_list['BASE_MODEL_DISCOUNTBOND'].averave()
# mrk_spot = result_list['BASE_FITTINGSPOT'].averave()
# mrk_forward = result_list['BASE_FITTINGFORWARD'].averave()
# rnd_z = result_list['BASE_RANDOMZ'].averave()
# print(shortrate_aver)
# print(shortrate[0])
# print(shortrate[1])
# plt.plot(discount)
# plt.plot(mrk_discount)
# plt.plot(mrk_spot)
i = 0
# for z, short_u_exp, short, spot, forward, mrk_disc, disc in zip(rnd_z, shortrate_uncon_expectation[0],
# shortrate_aver, mrk_spot, mrk_forward,
# mrk_discount[0], discount):
# print (
# str(i) + ' : ' + str(z) + ' , ' + str(short_u_exp) + ' , ' + str(short) + ' , ' + str(spot) + ' , ' + str(
# forward) + ' , ' + str(mrk_disc) + ' , ' + str(disc) + ' , ' + str(mrk_disc - disc))
# i += 1
# plt.plot(shortrate_aver)
# plt.plot(shortrate_uncon_expectation[0])
plt.figure(1)
plt.plot(res.timegrid.data['T'], shortrate.average(), label='shor_aver')
plt.plot(res.timegrid.data['T'],
shortrate_uncon_expectation.data[0],
label='short_analytic')
plt.title('short_aver vs short_analytic')
plt.xlabel('time (year)')
plt.ylabel('rate (%)')
plt.legend()
plt.figure(2)
plt.plot(res.timegrid.data['T'],
shortrate.average() - shortrate_uncon_expectation.data[0],
label='diff')
plt.title('short_aver - short_analytic')
plt.xlabel('time (year)')
plt.ylabel('rate (%)')
plt.legend()
# plt.plot(mrk_forward)
# pos = 360
# print(mrk_discount[0][pos])
# print(discount[pos])
#
# print(mrk_discount[0][pos] - discount[pos])
#
# print('disc diff ' + str(pos) + ' : ' + str(mrk_discount[0][pos] - discount[pos]))
plt.figure(3)
plt.title('discount - mrk_discount')
# plt.plot(mrk_discount[0])
# plt.plot(discount)
plt.plot(mrk_discount.data[0] - model_discount.average())
# plt.figure(4)
# plt.title('rand_z')
# plt.plot(rnd_z.average())
#print('aver Z : ' + rnd_z))
plt.show()
# assumption
# Daily Transaction ( Each country )
# Exchange Rate ( ex) USD/KRW , JPY/KRW ... )
# InterestRate of each country
# result
#
import xenarix as xen
scen_set = xen.ScenSet('testSet')
scen = xen.Scenario('testScen', 'resultID')
usd_curve = None
krw_curve = None
jpy_curve = None
vasicek_usd = None
vasicek_krw = None
vasicek_jpy = None
# fx model
usd_krw_fx = None
jpy_krw_fx = None
usd_jpy_fx = None
#
scen.add_model(vasicek_usd)
scen.add_model(vasicek_krw)
def generate(scenSetID, scenID, resultID):
maturity_tenors = ['5Y']
scen_set = xen.ScenarioSet(scenSetID)
scen = xen.Scenario(scenID, resultID)
usd_curve = xen.YieldCurve(None)
usd_curve.tenor = maturity_tenors
usd_curve.value = [ 0.02 ]
krw_curve = xen.YieldCurve(None)
krw_curve.tenor = maturity_tenors
krw_curve.value = [ 0.015 ]
jpy_curve = xen.YieldCurve(None)
jpy_curve.tenor = maturity_tenors
jpy_curve.value = [0.005]
vasicek_usd = xen.Vasicek1F('usd_shortrate')
vasicek_usd.r0 = 0.02
vasicek_usd.alpha = 0.1
vasicek_usd.sigma = 0.1
vasicek_usd.longterm = 0.1
vasicek_krw = xen.Vasicek1F('krw_shortrate')
vasicek_krw.r0 = 0.02
vasicek_krw.alpha = 0.1
vasicek_krw.sigma = 0.1
vasicek_krw.longterm = 0.1
vasicek_jpy = xen.Vasicek1F('jpy_shortrate')
vasicek_jpy.r0 = 0.02
vasicek_jpy.alpha = 0.1
vasicek_jpy.sigma = 0.1
vasicek_jpy.longterm = 0.1
# fx model
usd_krw_fx = xen.GarmanKohlhagen('usd_krw_fx')
usd_krw_fx.x0 = 1120
usd_krw_fx.dom_rf_curve = krw_curve
usd_krw_fx.for_rf_curve = usd_curve
usd_krw_fx.sigma_curve = xen.YieldCurve(None)
usd_krw_fx.sigma_curve.tenor = maturity_tenors
usd_krw_fx.sigma_curve.value = [0.1]
jpy_krw_fx = xen.GarmanKohlhagen('jpy_krw_fx')
jpy_krw_fx.x0 = 1000
jpy_krw_fx.dom_rf_curve = krw_curve
jpy_krw_fx.for_rf_curve = jpy_curve
jpy_krw_fx.sigma_curve = xen.YieldCurve(None)
jpy_krw_fx.sigma_curve.tenor = maturity_tenors
jpy_krw_fx.sigma_curve.value = [0.1]
usd_jpy_fx = xen.GarmanKohlhagen('usd_jpy_fx')
usd_jpy_fx.x0 = 1.1
usd_jpy_fx.dom_rf_curve = jpy_curve
usd_jpy_fx.for_rf_curve = usd_curve
usd_jpy_fx.sigma_curve = xen.YieldCurve(None)
usd_jpy_fx.sigma_curve.tenor = maturity_tenors
usd_jpy_fx.sigma_curve.value = [0.1]
#
scen.add_model(vasicek_usd)
scen.add_model(vasicek_krw)
scen.add_model(vasicek_jpy)
scen.add_model(usd_krw_fx)
scen.add_model(jpy_krw_fx)
scen.add_model(usd_jpy_fx)
scen.refresh_corr()
scen_set.add_scenario(scen)
scen_set.generate()
