def DFFormula(zeroCouponRate, refDate, dfDate, basis, compoundFormula,
compoundFrequency):
yf = yearFraction(refDate, dfDate, basis)
if compoundFormula == "EXPONENTIAL":
return math.exp(-zeroCouponRate * yf)
if compoundFormula == "COMPOUND":
return pow(1 / (1 + zeroCouponRate * compoundFrequency),
yf / compoundFrequency)
return 1 / (1 + zeroCouponRate * yf)
def ZCFormula(discountFactor, refDate, dfDate, basis, compoundFormula):
if (refDate == dfDate):
return 0
yf = yearFraction(refDate, dfDate, basis)
if compoundFormula == "EXPONENTIAL":
return -math.log(discountFactor) / yf
if compoundFormula == "COMPOUND":
return pow(1 / discountFactor, 1 / yf) - 1
if compoundFormula == "SIMPLE":
return (1 / discountFactor - 1) / yf
def calibrateHestonModel(surface):
calcDate = datetime.strptime(surface["calibrationDate"],"%Y-%m-%d")
for fxVolDef in surface["marketDataDefinitions"]["fxVolatilities"]:
volat_Id = fxVolDef["id"]
surfaceTenors = list(surface["marketData"]["fxVolatilities"][volat_Id]["values"].keys())[0]
smileLength = len(surface["marketData"]["fxVolatilities"]["EURGBP_Volatility"]["values"][surfaceTenors]["smileValues"])
volatilityBasis = fxVolDef["basis"]
nbExpiries = len(surface["marketData"]["fxVolatilities"][volat_Id]["values"].keys())
size = nbExpiries * smileLength
smileAxisType = surface["marketData"]["fxVolatilities"][volat_Id]["smileAxis"]
callOrPut = -1 if smileAxisType=="deltaPut" else 1
isPremiumAdjusted = fxVolDef["premiumAdjusted"]
forwards , expiries, dfs, = [], [], []
mktStrikes, mktVols = np.zeros((size,1)), np.zeros((size,1))
weights = np.ones((size,1))* math.sqrt(1.0 / size)
ycValuesDom, ycDefDom = list(surface["marketData"]["yieldCurves"][fxVolDef["domesticDiscountId"]]["values"].values()),getDFYC(surface["marketDataDefinitions"]["yieldCurves"],fxVolDef["domesticDiscountId"])
ycValuesFor, ycDefFor = list(surface["marketData"]["yieldCurves"][fxVolDef["foreignDiscountId"]]["values"].values()),getDFYC(surface["marketDataDefinitions"]["yieldCurves"],fxVolDef["foreignDiscountId"])
spotDate, spotRate = getFx(surface["marketData"]["fxRates"],fxVolDef["foreignCurrencyId"],fxVolDef["domesticCurrencyId"])
index = 0
for expiry,value in surface["marketData"]["fxVolatilities"][volat_Id]["values"].items():
yfExpiry = yearFraction(calcDate, datetime.strptime(expiry,"%Y-%m-%d"), volatilityBasis)
expiries = np.append(expiries , yfExpiry)
deliveryAsDays = datetime.strptime(value["delivery"],"%Y-%m-%d")
smileAxis = value["smileValues"]
volValues = value["volatilityValues"]
dfFor = discountFactorFromDays( ycValuesFor, ycDefFor, calcDate, spotDate, deliveryAsDays)
dfDom = discountFactorFromDays(ycValuesDom, ycDefDom,calcDate, spotDate, deliveryAsDays)
dfDomPv = computeDiscountFactor( ycValuesDom, ycDefDom, calcDate,deliveryAsDays)
forward = spotRate * dfFor / dfDom
dfs = np.append(dfs,dfDomPv)
forwards = np.append(forwards,forward)
deltaConvFactor = getDeltaConventionAdjustment(value["deltaConvention"], dfFor)
sqrtYf = math.sqrt(yfExpiry)
for j in range(smileLength):
vol = volValues[j]
strike = getStrikeFromSmileAxis(smileAxisType, forward, smileAxis[j], vol * sqrtYf, deltaConvFactor, isPremiumAdjusted, callOrPut)
mktStrikes[index] = strike
mktVols[index] = vol
weights[index] = 1 / math.sqrt(getNormedBlackVega(vol * sqrtYf, strike / forward, sqrtYf) * dfDomPv * forward)
index = index + 1
#initialVolATM is the first available by default.
initialVolATM = mktVols[math.floor(smileLength / 2)]
v0 = initialVolATM * initialVolATM
calibHelper = CalibrationHelper(expiries=expiries, forwards=forwards, dfs=dfs, strikes=mktStrikes, mktVols=mktVols, weights=weights, v0=v0)
initPoints = CHDEminimisationBestSolution(15, 35, 0.6, 0.75, 4, np.array([ 1, 1, 1, 10]), np.array([-1,1.0E-6, 0, 0]),
costFunction, calibHelper)
return getResultsWithV0(LevenbergMarquardt(costFunctionLV, initPoints, calibHelper, 4, size, 4, np.array([ 1, 1, 1, 10])),
v0, 4, calibHelper.kappa)
def post(self):
"""
yearFraction service
:return: the yearFraction between two dates
"""
content = request.get_json()
startDate = datetime.strptime(content["startDate"],"%Y-%m-%d")
endDate = datetime.strptime(content["endDate"],"%Y-%m-%d")
basis = content["basis"]
yf = yearFraction(startDate,endDate,basis)
# define model
return jsonify({"yearFraction":yf})
def constructFXVolSurface(data):
asOfDate = parse(data["asOfDate"])
surfaces = []
for fxVol in data["marketDataDefinitions"]["fxVolatilities"]:
expiryInput = fxVol["expiries"]
nbStrikesByExpiry = 2 * len(expiryInput[0]["butterflyQuoteIds"]) + 1
surface = np.zeros((len(expiryInput) * 7, nbStrikesByExpiry + 1))
nblines = 7 if fxVol[
"smileInterpolationMethod"] == "CUBIC_SPLINE" else 6
expirySmileCurve = np.zeros((nblines, nbStrikesByExpiry))
domCur = fxVol["domesticCurrencyId"]
forCur = fxVol["foreignCurrencyId"]
spotDate, underlyingSpotValue = getFxInput(
fxVol["currencyPairId"], data["marketData"]["fxRates"])
volatilityBasis = fxVol["basis"]
ycValuesDom, ycDefDom = getYcInput(
fxVol["domesticDiscountId"],
data["marketData"]["yieldCurveValues"],
data["marketDataDefinitions"]["yieldCurves"])
ycValuesFor, ycDefFor = getYcInput(
fxVol["foreignDiscountId"], data["marketData"]["yieldCurveValues"],
data["marketDataDefinitions"]["yieldCurves"])
smileCounter = 0
premiumAdjustmentIndicator = fxVol["premiumAdjusted"] * 1.0
isSmileBroker = fxVol["strategyConvention"] == "BROKER_STRANGLE"
for smileLine in fxVol["expiries"]:
deliveryDate = parse(smileLine["deliveryDate"])
dfFor = discountFactorFromDays(ycValuesFor, ycDefFor, asOfDate,
spotDate, deliveryDate)
dfDom = discountFactorFromDays(ycValuesDom, ycDefDom, asOfDate,
spotDate, deliveryDate)
sqrtVolYearFraction = math.sqrt(
yearFraction(asOfDate, parse(smileLine["expiryDate"]),
volatilityBasis))
forwardStrike = underlyingSpotValue * dfFor / dfDom
fxVolInfo = FxExpiryfxVolInfo(
forwardStrike, premiumAdjustmentIndicator,
getDeltaConventionAdjustment(smileLine["deltaConvention"],
dfFor), sqrtVolYearFraction,
dfDom, fxVol["id"], fxVol["smileInterpolationMethod"],
fxVol["smileInterpolationVariable"])
getExpirySmile(forCur,
domCur, nbStrikesByExpiry, smileLine, fxVolInfo,
pow(10, -6), underlyingSpotValue, expirySmileCurve,
isSmileBroker, data["marketData"])
fxCalibrationResultsDisplay(smileCounter, fxVolInfo,
expirySmileCurve, surface)
smileCounter = smileCounter + 1
surfaces.append(surface)
return surfaces
def test_act360(self):
"""ACT/360"""
yf = yearFraction(datetime.strptime("2012-02-25","%Y-%m-%d"),datetime.strptime("2013-01-13","%Y-%m-%d"),"ACT/360")
np.testing.assert_equal(yf, 0.8972222222222223,err_msg="WARNING : regression ACT/360")
def test_30E360(self):
"""ACT/366"""
yf = yearFraction(datetime.strptime("2014-02-25", "%Y-%m-%d"), datetime.strptime("2015-01-13", "%Y-%m-%d"),
"30E/360")
np.testing.assert_equal(yf, 0.8833333333333333, err_msg="WARNING : regression 30/360")
def test_30365(self):
"""ACT/366"""
yf = yearFraction(datetime.strptime("2014-03-31", "%Y-%m-%d"), datetime.strptime("2015-01-13", "%Y-%m-%d"),
"30/365")
np.testing.assert_equal(yf, 0.7753424657534247, err_msg="WARNING : regression 30/365")
def test_act365_25(self):
"""ACT/365.25"""
yf = yearFraction(datetime.strptime("2012-02-25", "%Y-%m-%d"), datetime.strptime("2013-01-13", "%Y-%m-%d"),
"ACT/365.25")
np.testing.assert_equal(yf, 0.8843258042436687, err_msg="WARNING : regression ACT/365.25")
def test_act365_equal(self):
"""ACT/365"""
yf = yearFraction(datetime.strptime("2012-02-25", "%Y-%m-%d"), datetime.strptime("2012-02-25", "%Y-%m-%d"),
"ACT/365")
np.testing.assert_equal(yf, 0.0, err_msg="WARNING : regression ACT/365 EQUAL")