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 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 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()
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())
# coding=euc-kr import xenarix as xen xen.set_repository( 'C:\\Users\\09928829\\Source\\Workspaces\\InsuranceHedgeProject\\InsruranceHedge_sln\\Project\\Scenario\\xenarixPy\\test_repository' ) set_name = 'setname_1' scen_id = 'testscen_1' result_id = 'testresult_1' set1 = xen.ScenarioSet(set_name) scen1 = xen.Scenario(scen_id, result_id) scen1.general.scenario_num = 30 gbm1 = xen.GBM('gbm1') gbm1.rf_curve.tenor = [ '3M', '6M', '9M', '12M', '24M', '36M', '48M', '60M', '120M', '180M' ] gbm1.rf_curve.value = [ 0.0164, 0.0161, 0.0159, 0.0164, 0.0173, 0.0182, 0.0191, 0.0218, 0.0229, 0.0229 ] gbm1.div_curve.tenor = ['15Y'] gbm1.div_curve.value = [0.005] gbm1.sigma_curve.tenor = ['15Y'] gbm1.sigma_curve.value = [0.3]
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()
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()
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()
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
# 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
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()