/// <summary>
/// Calculate the fra value from the given curve
/// </summary>
/// <param name="rateCurve">rate curve</param>
/// <param name="fraStartDates">List of fra start dates</param>
/// <param name="fraEndDates">List of fra end dates</param>
/// <returns></returns>
public List <decimal> CalculateFraValuesFromCurve(RateCurve rateCurve,
List <DateTime> fraStartDates,
List <DateTime> fraEndDates)
{
var calculatedFraRates = new List <decimal>();
int len = fraStartDates.Count;
for (int i = 0; i < len; ++i)
{
decimal df1 = Convert.ToDecimal(rateCurve.GetDiscountFactor(fraStartDates[i]));
decimal df2 = Convert.ToDecimal(rateCurve.GetDiscountFactor(fraEndDates[i]));
double period = DayCounter.YearFraction(fraStartDates[i], fraEndDates[i]);
decimal fraRate = CalculateForwardRate(df1, df2, (decimal)period);
calculatedFraRates.Add(fraRate);
}
return(calculatedFraRates);
}
public double LongEndTargetFunction(double zeroRateSpread)
{
DateTime baseDate = _baseCurve.GetBaseDate();
DateTime maturityDate = _asset.GetRiskMaturityDate();
_zeroRateSpreads[maturityDate] = zeroRateSpread;
decimal dfMaturityBasisAdjustCurve
= (decimal)RateBootstrapperNewtonRaphson.GetAdjustedDiscountFactor(baseDate, maturityDate, _dayCounter,
zeroRateSpread, _baseCurve);
UpdateDiscountFactors(baseDate);
if (_items.ContainsKey(maturityDate))
{
_items[maturityDate].Second = dfMaturityBasisAdjustCurve;
}
else
{
Pair <string, decimal> pair = new Pair <string, decimal>("", dfMaturityBasisAdjustCurve);
_items.Add(maturityDate, pair);
}
List <DateTime> dates = _items.Keys.ToList();
List <decimal> rates = _items.Values.Select(a => a.Second).ToList();
RateCurve discountCurve = new RateCurve(_properties, _algorithm, dates, rates);
double sum = 0;
for (int i = 0; i < _assetDates.Count - 1; i++)
{
DateTime date0 = _assetDates[i];
DateTime date1 = _assetDates[i + 1];
double d0 = _baseCurve.GetDiscountFactor(date0);
double d1 = _baseCurve.GetDiscountFactor(date1);
double y = _dayCounter.YearFraction(date0, date1);
double projectedRate = 1 / y * (d0 / d1 - 1);
double basisAdjustedDf = discountCurve.GetDiscountFactor(date1);
double subSum = basisAdjustedDf * y * (projectedRate + (double)_asset.MarketQuote.value);
sum += subSum;
}
double discountFactor = discountCurve.GetDiscountFactor(_assetDates.First());
double result = -discountFactor + (double)dfMaturityBasisAdjustCurve + sum;
return(result);
}
public double Value(double fixedRate)
{
List <BillSwapPricer2CashflowItem> floatCFs = GenerateFloatingCashflowsFromAmortisingResultItems(_floatCFs, _dayCounter, _curve,
_floatRateMargin);
List <BillSwapPricer2CashflowItem> fixedCFs = GenerateFixedCashflowsFromAmortisingResultItems(_fixedCFs, _dayCounter, fixedRate);
// Float side PV
//
double floatPV = (from cf in floatCFs
let floatInterest = cf.Notional - cf.DiscountedValue
select floatInterest * _curve.GetDiscountFactor(_valuationDate, cf.StartDate)).Sum();
// Fixed side PV
//
double fixedPV = (from cf in fixedCFs
let fixedInterest = cf.Notional - cf.DiscountedValue
select fixedInterest * _curve.GetDiscountFactor(_valuationDate, cf.StartDate)).Sum();
// we pay to client
//
double bulletPaymentPresentValue = _bulletPaymentValue * _curve.GetDiscountFactor(_valuationDate, _bulletPaymentDate);
return(floatPV + bulletPaymentPresentValue - fixedPV);
}
/// <summary>
/// Creates synthetic swaps from FX curve for period under 1 year
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="logger">The logger.</param>
/// <param name="fixingCalendar">The fixingCalendar.</param>
/// <param name="rollCalendar">The rollCalendar.</param>
/// <param name="nameSpace">THe client namespace</param>
/// <param name="baseCurve"></param>
/// <param name="basisAdjustedDiscountCurve"></param>
/// <param name="currency"></param>
/// <param name="baseDate"></param>
/// <param name="swapsRequired">Array of the names of the swaps required</param>
/// <returns></returns>
public static List <IPriceableRateAssetController> CreateSyntheticSwaps(ILogger logger, ICoreCache cache, string nameSpace, IRateCurve baseCurve,
RateCurve basisAdjustedDiscountCurve, string currency, DateTime baseDate, string[] swapsRequired, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar)
{
var dummyRates = new decimal[5];
string[] swapIds = swapsRequired.Select(a => currency + "-XccySwap-" + a).ToArray();
List <IPriceableRateAssetController> priceableRateAssets
= PriceableAssetFactory.CreatePriceableRateAssets(logger, cache, nameSpace, baseDate, swapIds, dummyRates, null, fixingCalendar, rollCalendar);
foreach (var priceableRateAssetController in priceableRateAssets)
{
var swap = (PriceableSimpleIRSwap)priceableRateAssetController;
DateTime date0 = swap.AdjustedStartDate;
DateTime date1 = swap.GetRiskMaturityDate();
IDayCounter dayCounter = DayCounterHelper.Parse(swap.DayCountFraction.Value);
double adjustedDiscountFactorStart = basisAdjustedDiscountCurve.GetDiscountFactor(date0);
double adjustedDiscountFactorEnd = basisAdjustedDiscountCurve.GetDiscountFactor(date1);
double term3 = 0;
double term4 = 0;
for (int i = 0; i < swap.AdjustedPeriodDates.Count - 1; i++)
{
DateTime startDate = swap.AdjustedPeriodDates[i];
DateTime endDate = swap.AdjustedPeriodDates[i + 1];
if (startDate == endDate)
{
throw new InvalidOperationException("StartDate and EndDate cannot be the same");
}
double adjustedDiscountFactor = basisAdjustedDiscountCurve.GetDiscountFactor(endDate);
double baseDiscountFactorStart = baseCurve.GetDiscountFactor(startDate);
double baseDiscountFactorEnd = baseCurve.GetDiscountFactor(endDate);
double yearFraction = dayCounter.YearFraction(startDate, endDate);
double baseForwardRate = (1 / yearFraction) * (baseDiscountFactorStart / baseDiscountFactorEnd - 1);
term3 += yearFraction * adjustedDiscountFactor * baseForwardRate;
term4 += yearFraction * adjustedDiscountFactor;
}
swap.MarketQuote.value = (decimal)((adjustedDiscountFactorStart - adjustedDiscountFactorEnd - term3) / term4);
swap.BasicAssetValuation.quote[0].value = swap.MarketQuote.value;
}
return(priceableRateAssets);
}
internal static List <BillSwapPricer2CashflowItem> GenerateFloatingCashflowsFromAmortisingResultItems(List <AmortisingResultItem> amortisingResultItems, IDayCounter dayCounter, RateCurve curve, double floatRateMargin)
{
var result = new List <BillSwapPricer2CashflowItem>();
for (int i = 0; i < amortisingResultItems.Count - 1; ++i)
{
var billSwapPricer2CashflowItem = new BillSwapPricer2CashflowItem
{
StartDate = amortisingResultItems[i].RollDate,
EndDate = amortisingResultItems[i + 1].RollDate,
Notional = amortisingResultItems[i].OutstandingValue
};
billSwapPricer2CashflowItem.AccrualPeriod = dayCounter.YearFraction(billSwapPricer2CashflowItem.StartDate, billSwapPricer2CashflowItem.EndDate);
double startOfPeriodDiscount = curve.GetDiscountFactor(billSwapPricer2CashflowItem.StartDate);
double endOfPeriodDiscount = curve.GetDiscountFactor(billSwapPricer2CashflowItem.EndDate);
double forecastContinuouslyCompoundingRate = floatRateMargin + ((startOfPeriodDiscount / endOfPeriodDiscount - 1.0) / billSwapPricer2CashflowItem.AccrualPeriod);
billSwapPricer2CashflowItem.ImpliedForwardRate = forecastContinuouslyCompoundingRate;
billSwapPricer2CashflowItem.DiscountedValue = billSwapPricer2CashflowItem.Notional /
(1 + billSwapPricer2CashflowItem.ImpliedForwardRate * billSwapPricer2CashflowItem.AccrualPeriod);
result.Add(billSwapPricer2CashflowItem);
}
return(result);
}
internal static TermCurve ConstructDiscountFactors(ILogger logger, ICoreCache cache, string nameSpace, TermCurve inputCurve, DateTime baseDate, string currency)
{
List <DateTime> dates = inputCurve.point.Select(a => (DateTime)a.term.Items[0]).ToList();
List <decimal> values = inputCurve.point.Select(a => a.mid).ToList();
var properties = new NamedValueSet();
properties.Set(CurveProp.PricingStructureType, PricingStructureTypeEnum.RateCurve.ToString());
properties.Set(CurveProp.Market, "ConstructDiscountFactors");
properties.Set(CurveProp.IndexTenor, "0M");
properties.Set(CurveProp.Currency1, currency);
properties.Set(CurveProp.IndexName, "XXX-XXX");
properties.Set(CurveProp.Algorithm, "FastLinearZero");
properties.Set(CurveProp.BaseDate, baseDate);
var curveId = new RateCurveIdentifier(properties);
var algorithmHolder = new PricingStructureAlgorithmsHolder(logger, cache, nameSpace, curveId.PricingStructureType, curveId.Algorithm);
var curve = new RateCurve(properties, algorithmHolder, dates, values);
var termPoints = new List <TermPoint>();
for (DateTime date = dates.First(); date <= dates.Last(); date = date.AddMonths(1))
{
var discountFactor = (decimal)curve.GetDiscountFactor(date);
var timeDimension = new TimeDimension();
XsdClassesFieldResolver.TimeDimensionSetDate(timeDimension, date);
var termPoint = new TermPoint
{
mid = discountFactor,
midSpecified = true,
term = timeDimension
};
termPoints.Add(termPoint);
}
var termCurve = new TermCurve {
point = termPoints.ToArray()
};
return(termCurve);
}