def test_LiborSwap(): # I have tried to reproduce the example from the blog by Ioannis Rigopoulos # https://blog.deriscope.com/index.php/en/excel-interest-rate-swap-price-dual-bootstrapping-curve startDate = FinDate(2017, 12, 27) endDate = FinDate(2067, 12, 27) fixedCoupon = 0.015 fixedFreqType = FinFrequencyTypes.ANNUAL fixedDayCountType = FinDayCountTypes.THIRTY_E_360 floatSpread = 0.0 floatFreqType = FinFrequencyTypes.SEMI_ANNUAL floatDayCountType = FinDayCountTypes.ACT_360 firstFixing = -0.00268 swapCalendarType = FinCalendarTypes.WEEKEND busDayAdjustType = FinBusDayAdjustTypes.FOLLOWING dateGenRuleType = FinDateGenRuleTypes.BACKWARD swapType = FinLiborSwapTypes.RECEIVER notional = 10.0 * ONE_MILLION swap = FinLiborSwap(startDate, endDate, swapType, fixedCoupon, fixedFreqType, fixedDayCountType, notional, floatSpread, floatFreqType, floatDayCountType, swapCalendarType, busDayAdjustType, dateGenRuleType) ''' Now perform a valuation after the swap has seasoned but with the same curve being used for discounting and working out the implied future Libor rates. ''' valuationDate = FinDate(30, 11, 2018) settlementDate = valuationDate.addDays(2) liborCurve = buildLiborCurve(valuationDate) v = swap.value(settlementDate, liborCurve, liborCurve, firstFixing) v_bbg = 388147.0 testCases.header("LABEL", "VALUE") testCases.print("SWAP_VALUE USING ONE_CURVE", v) testCases.print("BLOOMBERG VALUE", v_bbg) testCases.print("DIFFERENCE VALUE", v_bbg - v)
def test_dp_example(): # http://www.derivativepricing.com/blogpage.asp?id=8 startDate = FinDate(14, 11, 2011) endDate = FinDate(14, 11, 2016) fixedFreqType = FinFrequencyTypes.SEMI_ANNUAL swapCalendarType = FinCalendarTypes.TARGET busDayAdjustType = FinBusDayAdjustTypes.MODIFIED_FOLLOWING dateGenRuleType = FinDateGenRuleTypes.BACKWARD fixedDayCountType = FinDayCountTypes.THIRTY_E_360_ISDA swapType = FinLiborSwapTypes.PAYER fixedCoupon = 0.0124 notional = ONE_MILLION swap = FinLiborSwap(startDate, endDate, swapType, fixedCoupon=fixedCoupon, fixedFreqType=fixedFreqType, fixedDayCountType=fixedDayCountType, floatFreqType=FinFrequencyTypes.SEMI_ANNUAL, floatDayCountType=FinDayCountTypes.ACT_360, notional=notional, calendarType=swapCalendarType, busDayAdjustType=busDayAdjustType, dateGenRuleType=dateGenRuleType) # swap.printFixedLegFlows() dts = [FinDate(14, 11, 2011), FinDate(14, 5, 2012), FinDate(14, 11, 2012), FinDate(14, 5, 2013), FinDate(14, 11, 2013), FinDate(14, 5, 2014), FinDate(14, 11, 2014), FinDate(14, 5, 2015), FinDate(16, 11, 2015), FinDate(16, 5, 2016), FinDate(14, 11, 2016)] dfs = [0.9999843, 0.9966889, 0.9942107, 0.9911884, 0.9880738, 0.9836490, 0.9786276, 0.9710461, 0.9621778, 0.9514315, 0.9394919] valuationDate = startDate curve = FinDiscountCurve(valuationDate, dts, np.array(dfs), FinInterpTypes.FLAT_FORWARDS) v = swap.value(valuationDate, curve, curve) # swap.printFixedLegPV() # swap.printFloatLegPV() # This is essentially zero testCases.header("LABEL", "VALUE") testCases.print("Swap Value on a Notional of $1M:", v)
def test_FinLiborBermudanSwaptionBKModel(): ''' Replicate examples in paper by Leif Andersen which can be found at file:///C:/Users/Dominic/Downloads/SSRN-id155208.pdf ''' valuationDate = FinDate(1, 1, 2011) settlementDate = valuationDate exerciseDate = settlementDate.addYears(1) swapMaturityDate = settlementDate.addYears(4) swapFixedCoupon = 0.060 swapFixedFrequencyType = FinFrequencyTypes.SEMI_ANNUAL swapFixedDayCountType = FinDayCountTypes.ACT_365F liborCurve = FinDiscountCurveFlat(valuationDate, 0.0625, FinFrequencyTypes.SEMI_ANNUAL) fwdPayerSwap = FinLiborSwap(exerciseDate, swapMaturityDate, FinLiborSwapTypes.PAYER, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) fwdSwapValue = fwdPayerSwap.value(settlementDate, liborCurve, liborCurve) testCases.header("LABEL", "VALUE") testCases.print("FWD SWAP VALUE", fwdSwapValue) # fwdPayerSwap.printFixedLegPV() # Now we create the European swaptions swapType = FinLiborSwapTypes.PAYER europeanSwaptionPay = FinLiborSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER europeanSwaptionRec = FinLiborSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) ########################################################################### ########################################################################### ########################################################################### # BLACK'S MODEL ########################################################################### ########################################################################### ########################################################################### testCases.banner("======= ZERO VOLATILITY ========") model = FinModelBlack(0.0000001) testCases.print("Black Model", model._volatility) valuePay = europeanSwaptionPay.value(settlementDate, liborCurve, model) testCases.print("EUROPEAN BLACK PAY VALUE ZERO VOL:", valuePay) valueRec = europeanSwaptionRec.value(settlementDate, liborCurve, model) testCases.print("EUROPEAN BLACK REC VALUE ZERO VOL:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 20%% BLACK VOLATILITY ========") model = FinModelBlack(0.20) testCases.print("Black Model", model._volatility) valuePay = europeanSwaptionPay.value(settlementDate, liborCurve, model) testCases.print("EUROPEAN BLACK PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(settlementDate, liborCurve, model) testCases.print("EUROPEAN BLACK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### ########################################################################### ########################################################################### # BK MODEL ########################################################################### ########################################################################### ########################################################################### testCases.banner("=======================================================") testCases.banner("=======================================================") testCases.banner("==================== BK MODEL =========================") testCases.banner("=======================================================") testCases.banner("=======================================================") testCases.banner("======= 0% VOLATILITY EUROPEAN SWAPTION BK MODEL ======") # Used BK with constant short-rate volatility sigma = 0.00001 a = 0.01 numTimeSteps = 200 model = FinModelRatesBK(sigma, a, numTimeSteps) valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BK PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 20% VOLATILITY EUROPEAN SWAPTION BK MODEL ========") # Used BK with constant short-rate volatility sigma = 0.20 a = 0.01 model = FinModelRatesBK(sigma, a, numTimeSteps) testCases.banner("BK MODEL SWAPTION CLASS EUROPEAN EXERCISE") valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BK PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### # Now we create the Bermudan swaptions but only allow European exercise swapType = FinLiborSwapTypes.PAYER exerciseType = FinOptionExerciseTypes.EUROPEAN bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER exerciseType = FinOptionExerciseTypes.EUROPEAN bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) testCases.banner("======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BK MODEL ========") # Used BK with constant short-rate volatility sigma = 0.000001 a = 0.01 model = FinModelRatesBK(sigma, a, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BK MODEL ========") # Used BK with constant short-rate volatility sigma = 0.2 a = 0.01 model = FinModelRatesBK(sigma, a, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### # Now we create the Bermudan swaptions but allow Bermudan exercise ########################################################################### swapType = FinLiborSwapTypes.PAYER exerciseType = FinOptionExerciseTypes.BERMUDAN bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER exerciseType = FinOptionExerciseTypes.BERMUDAN bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) testCases.banner("======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BK MODEL ========") # Used BK with constant short-rate volatility sigma = 0.000001 a = 0.01 model = FinModelRatesBK(sigma, a, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BK MODEL ========") # Used BK with constant short-rate volatility sigma = 0.20 a = 0.01 model = FinModelRatesBK(sigma, a, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BK REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### ########################################################################### ########################################################################### # BDT MODEL ########################################################################### ########################################################################### ########################################################################### testCases.banner("=======================================================") testCases.banner("=======================================================") testCases.banner("======================= BDT MODEL =====================") testCases.banner("=======================================================") testCases.banner("=======================================================") testCases.banner("====== 0% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======") # Used BK with constant short-rate volatility sigma = 0.00001 numTimeSteps = 200 model = FinModelRatesBDT(sigma, numTimeSteps) valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BDT PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("===== 20% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======") # Used BK with constant short-rate volatility sigma = 0.20 a = 0.01 model = FinModelRatesBDT(sigma, numTimeSteps) testCases.banner("BDT MODEL SWAPTION CLASS EUROPEAN EXERCISE") valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BDT PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### # Now we create the Bermudan swaptions but only allow European exercise swapType = FinLiborSwapTypes.PAYER exerciseType = FinOptionExerciseTypes.EUROPEAN bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) testCases.banner("======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========") # Used BK with constant short-rate volatility sigma = 0.000001 model = FinModelRatesBDT(sigma, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========") # Used BK with constant short-rate volatility sigma = 0.2 model = FinModelRatesBDT(sigma, numTimeSteps) testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### # Now we create the Bermudan swaptions but allow Bermudan exercise ########################################################################### swapType = FinLiborSwapTypes.PAYER exerciseType = FinOptionExerciseTypes.BERMUDAN bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) testCases.banner("======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BDT MODEL ========") # Used BK with constant short-rate volatility sigma = 0.000001 a = 0.01 model = FinModelRatesBDT(sigma, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 20% VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BDT MODEL ========") # Used BK with constant short-rate volatility sigma = 0.20 a = 0.01 model = FinModelRatesBDT(sigma, numTimeSteps) print("BDT MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### ########################################################################### ########################################################################### # BDT MODEL ########################################################################### ########################################################################### ########################################################################### testCases.banner("=======================================================") testCases.banner("=======================================================") testCases.banner("======================= HW MODEL ======================") testCases.banner("=======================================================") testCases.banner("=======================================================") testCases.banner("====== 0% VOLATILITY EUROPEAN SWAPTION HW MODEL ======") sigma = 0.0000001 a = 0.1 numTimeSteps = 200 model = FinModelRatesHW(sigma, a, numTimeSteps) valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN HW PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN HW REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("===== 20% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======") # Used BK with constant short-rate volatility sigma = 0.01 a = 0.01 model = FinModelRatesHW(sigma, a, numTimeSteps) testCases.banner("HW MODEL SWAPTION CLASS EUROPEAN EXERCISE") valuePay = europeanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN HW PAY VALUE:", valuePay) valueRec = europeanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("EUROPEAN HW REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### # Now we create the Bermudan swaptions but only allow European exercise swapType = FinLiborSwapTypes.PAYER exerciseType = FinOptionExerciseTypes.EUROPEAN bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) testCases.banner("======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========") sigma = 0.000001 model = FinModelRatesHW(sigma, a, numTimeSteps) testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 100bp VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========") # Used BK with constant short-rate volatility sigma = 0.01 model = FinModelRatesHW(sigma, a, numTimeSteps) testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN BDT REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) ########################################################################### # Now we create the Bermudan swaptions but allow Bermudan exercise ########################################################################### swapType = FinLiborSwapTypes.PAYER exerciseType = FinOptionExerciseTypes.BERMUDAN bermudanSwaptionPay = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) swapType = FinLiborSwapTypes.RECEIVER bermudanSwaptionRec = FinLiborBermudanSwaption(settlementDate, exerciseDate, swapMaturityDate, swapType, exerciseType, swapFixedCoupon, swapFixedFrequencyType, swapFixedDayCountType) testCases.banner("======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE HW MODEL ========") # Used BK with constant short-rate volatility sigma = 0.000001 a = 0.01 model = FinModelRatesHW(sigma, a, numTimeSteps) testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN HW PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN HW REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec) testCases.banner("======= 100bps VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE HW MODEL ========") # Used BK with constant short-rate volatility sigma = 0.01 a = 0.01 model = FinModelRatesHW(sigma, a, numTimeSteps) testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE") valuePay = bermudanSwaptionPay.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN HW PAY VALUE:", valuePay) valueRec = bermudanSwaptionRec.value(valuationDate, liborCurve, model) testCases.print("BERMUDAN HW REC VALUE:", valueRec) payRec = valuePay - valueRec testCases.print("PAYER MINUS RECEIVER :", payRec)