public Deposit FindDeposit(InterestRate rate)
{
if (rate.InstrumentType != InstrumentType.Deposit)
throw new Exception("Instrument is not a Deposit");
string tableName = _depositTableName;
string searchString = "ID = " + rate.ID;
string targetString = null;
DataTable table = Database.DB["Kernel"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
return null;
DataRow r = rows[0];
DayCountConvention dayCountConvention = (DayCountConvention)GetValue<int>(r, "DayCountConvention");
Deposit deposit = new Deposit(rate, dayCountConvention);
_deposits.Add(deposit.ID, deposit);
if (_mainTables.ContainsKey(deposit.ID))
_mainTables[deposit.ID] = table;
else
_mainTables.Add(deposit.ID, table);
return deposit;
}
public void TestDayCounts()
{
var date1 = new Date(2003, 11, 1);
var date2 = new Date(2004, 5, 1);
// Actual/365
Assert.AreEqual(182.0 / 365, DayCountStore.Actual365Fixed.YearFraction(date1, date2), 1e-9);
// Actual/360
Assert.AreEqual(182.0 / 360, DayCountStore.Actual360.YearFraction(date1, date2), 1e-9);
// Actual/Actual ISDA
Assert.AreEqual(61.0 / 365 + 121.0 / 366, DayCountStore.ActActISDA.YearFraction(date1, date2), 1e-9);
Assert.AreEqual(0.497724380567, DayCountStore.ActActISDA.YearFraction(date1, date2), 1e-9); // QuantLib case
// 30/360
date1 = new Date(2008, 2, 28);
date2 = new Date(2008, 3, 31);
Assert.AreEqual(32.0 / 360, DayCountStore.Thirty360Euro.YearFraction(date1, date2), 1e-9); // QuantLib case
// Business 252
var weekendsOnly = new Calendar(new List <Date>());
var weekendsAndOneHoliday = new Calendar(new List <Date> {
new Date(2008, 3, 21)
});
DayCountConvention business252Weekends = DayCountStore.Business252(weekendsOnly);
DayCountConvention business252WeekendsAndHolday = DayCountStore.Business252(weekendsAndOneHoliday);
Assert.AreEqual(22.0 / 252, business252Weekends.YearFraction(date1, date2), 1e-9);
Assert.AreEqual(21.0 / 252, business252WeekendsAndHolday.YearFraction(date1, date2), 1e-9);
}
public Deposit CreateDeposit(InterestRate rate, DayCountConvention dayCount)
{
if (rate.InstrumentType != InstrumentType.Deposit)
{
throw new Exception("Instrument is not a Deposit");
}
string searchString = null;// "Name LIKE '" + name + "'";
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(_depositTableName, targetString, searchString);
DataRowCollection rows = table.Rows;
var lrows = from lrow in new LINQList <DataRow>(rows)
where GetValue <int>(lrow, "ID") == rate.ID
select lrow;
if (lrows.Count() == 0)
{
DataRow r = table.NewRow();
r["ID"] = rate.ID;
r["DayCountConvention"] = (int)dayCount;
rows.Add(r);
Database.DB["Quant"].UpdateDataTable(table);
return(FindDeposit(rate));
}
throw new Exception("Deposit Already Exists");
}
public static double ComputeAccruedInterest(Bond bond, double constantAnnualInterestRate,
DateTime startDate, DateTime endDate,
DayCountConvention dcc, DayRollingConvention drc)
{
var yearFraction = GetDayCountConventionNumerator(startDate, endDate, dcc) / GetDayCountConventionDenominator(startDate, endDate, dcc);
return(yearFraction * bond.FaceValue * constantAnnualInterestRate);
}
public CashFlowRate(InterestRateTenorType frequencyType, int frequency, InterestRateTenorType maturityType, int maturity, DayCountConvention dayCount, double rate)
{
this._frequencyType = frequencyType;
this._frequency = frequency;
this._maturityType = maturityType;
this._maturity = maturity;
this._dayCount = dayCount;
this._rate = rate;
}
/// <summary>Creates a specified 'BU/252' day count convention used for Brazilian trades.
/// </summary>
/// <param name="holidayCalendar">The holiday calendar.</param>
/// <param name="addToPool">The return value will be stored into the <see cref="DayCountConvention"/> pool for later use.</param>
/// <returns>The specified 'BU/252' day count convention used for Brazilian trades. This day count fraction is defined as the numbers
/// of business days in the period over 252the specified holiday calendar.</returns>
public IDayCountConvention Create(IHolidayCalendar holidayCalendar, bool addToPool = false)
{
IDayCountConvention dayCountConvention = new DayCountConventionImplementation(holidayCalendar);
if (addToPool == true)
{
DayCountConvention.Add(dayCountConvention);
}
return(dayCountConvention);
}
public static double GetYearFraction([QuantSAExcelArgument(Description = "The first date.")]
Date date1,
[QuantSAExcelArgument(Description = "The second date.")]
Date date2,
[QuantSAExcelArgument(Description = "The day count convention to use for getting the accrual fraction.")]
DayCountConvention convention)
{
return(convention.YearFraction(date1, date2));
}
internal static double GetDiscountFactor(int Term, List <Rate> Rates, DayCountConvention dayCount)
{
double ret = 0;
double daysInYr = DaysInYear(dayCount);
double discountRate = GetRateFromCurve(Term, Rates);
ret = GetDiscountFactorFromRate(discountRate, Term, daysInYr);
return(ret);
}
/// <summary>
/// Interest = Principal x Coupon x DayCountFactor
/// </summary>
public static double DayCountFactor(DayCountConvention dayCountConvention, DateTime date1, DateTime date2, DateTime date3, PaymentFrequency paymentFrequency)
{
switch (dayCountConvention)
{
case DayCountConvention.ActActUS:
return((date2 - date1).Days / ((double)paymentFrequency * (date3 - date1).Days));
default:
throw new Exception(string.Format(@"No DayCountFactor method for DayCountConvention = {0}", dayCountConvention));
}
}
public void CalculateForwardPoints_ThrowsException_WhenSpotNegative()
{
const decimal spot = -1m;
const int days = 184;
const decimal baseInterestRate = 0.06m;
const decimal quotedInterestRate = 0.02m;
const DayCountConvention baseDayCount = DayCountConvention._360;
const DayCountConvention quotedDayCount = DayCountConvention._360;
Assert.Throws <ArgumentOutOfRangeException>(() => _forwardCalculator.CalculateForwardPoints(spot, days, baseInterestRate, baseDayCount, quotedInterestRate, quotedDayCount));
}
public CurveRecipe(Guid id, Tenor lastLiquidTenor, DayCountConvention dayCountConvention, Interpolation interpolation,
ExtrapolationShort extrapolationShort, ExtrapolationLong extrapolationLong, OutputFrequency outputFrequency, OutputType outputType, params OrderedTransformation[] transformations)
{
Id = id;
LastLiquidTenor = lastLiquidTenor;
DayCountConvention = dayCountConvention;
Interpolation = interpolation;
ExtrapolationShort = extrapolationShort;
ExtrapolationLong = extrapolationLong;
OutputFrequency = outputFrequency;
OutputType = outputType;
_transformations = transformations?.ToImmutableArray() ?? ImmutableArray <OrderedTransformation> .Empty;
}
public void CalculateForwardPoints_Calculates_WhenSimple()
{
const decimal spot = 1.5m;
const int days = 184;
const decimal baseInterestRate = 0.06m;
const decimal quotedInterestRate = 0.02m;
const DayCountConvention baseDayCount = DayCountConvention._360;
const DayCountConvention quotedDayCount = DayCountConvention._360;
decimal fowardRate = _forwardCalculator.CalculateForwardPoints(spot, days, baseInterestRate, baseDayCount, quotedInterestRate, quotedDayCount);
Assert.That(fowardRate, Is.EqualTo(-0.0000297542043984476067270375M));
}
public void CalculateForwardRate_Calculates_WhenSimple()
{
const decimal spot = 1.5m;
const int days = 184;
const decimal baseInterestRate = 0.06m;
const decimal quotedInterestRate = 0.02m;
const DayCountConvention baseDayCount = DayCountConvention._360;
const DayCountConvention quotedDayCount = DayCountConvention._360;
decimal fowardRate = _forwardCalculator.CalculateForwardRate(spot, days, baseInterestRate, baseDayCount, quotedInterestRate, quotedDayCount);
Assert.That(fowardRate, Is.EqualTo(1.4702457956015523932729624837m));
}
public InterestRateSwap FindInterestRateSwap(InterestRate instrument)
{
lock (objLock)
{
if (_swaps.ContainsKey(instrument.ID))
{
return(_swaps[instrument.ID]);
}
if (instrument.InstrumentType != InstrumentType.InterestRateSwap)
{
throw new Exception("Instrument is not an Interest Rate Swap");
}
string tableName = _interestRateSwapTableName;
string searchString = "ID = " + instrument.ID;
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
{
return(null);
}
DataRow r = rows[0];
int floatFrequency = GetValue <int>(r, "FloatFrequency");
InterestRateTenorType floatFrequencyType = (InterestRateTenorType)GetValue <int>(r, "FloatFrequencyType");
DayCountConvention floatDayCountConvention = (DayCountConvention)GetValue <int>(r, "FloatDayCountConvention");
int fixedFrequency = GetValue <int>(r, "FixedFrequency");
InterestRateTenorType fixedFrequencyType = (InterestRateTenorType)GetValue <int>(r, "FixedFrequencyType");
DayCountConvention fixedDayCountConvention = (DayCountConvention)GetValue <int>(r, "FixedDayCountConvention");
int effective = GetValue <int>(r, "Effective");
InterestRateSwap swap = new InterestRateSwap(instrument, floatFrequency, floatFrequencyType, floatDayCountConvention, fixedFrequency, fixedFrequencyType, fixedDayCountConvention, effective);
_swaps.Add(swap.ID, swap);
if (_mainTables.ContainsKey(swap.ID))
{
_mainTables[swap.ID] = table;
}
else
{
_mainTables.Add(swap.ID, table);
}
return(swap);
}
}
internal static int DaysBetween(DateTime StartDate, DateTime EndDate, DayCountConvention dayCountConvention)
{
int ret = 0;
int day1, day2, months, years;
switch (dayCountConvention)
{
case DayCountConvention.eActual_360:
case DayCountConvention.eActual_365:
case DayCountConvention.eActual_Actual:
case DayCountConvention.eActualNL_365:
ret = (int)EndDate.Subtract(StartDate).TotalDays;
break;
default:
// Gets the No of days between when the convention is something over 360
years = (EndDate.Year - StartDate.Year) * 360;
months = (EndDate.Month - StartDate.Month) * 30;
day1 = StartDate.Day;
day2 = EndDate.Day;
if (day1 == 31)
{
day1 = 30;
}
switch (dayCountConvention)
{
case DayCountConvention.e30_360:
if (day2 == 31 && day1 == 30)
{
day2 = 30;
}
break;
case DayCountConvention.e30E_360:
if (day2 == 31)
{
day2 = 30;
}
break;
}
ret = years + months + (day2 - day1);
break;
}
return(ret);
}
public InterestRateSwap(InterestRate rate,
int floatFrequency,
InterestRateTenorType floatFrequencyType,
DayCountConvention floatDayCountConvention,
int fixedFrequency,
InterestRateTenorType fixedFrequencyType,
DayCountConvention fixedDayCountConvention,
int effective)
: base(rate, rate.Maturity, rate.MaturityType)
{
this._floatFrequency = floatFrequency;
this._floatFrequencyType = floatFrequencyType;
this._floatDayCountConvention = floatDayCountConvention;
this._fixedFrequency = fixedFrequency;
this._fixedFrequencyType = fixedFrequencyType;
this._fixedDayCountConvention = fixedDayCountConvention;
this._effective = effective;
}
private static int GetDayCountConventionNumerator(DateTime dateOne, DateTime dateTwo,
DayCountConvention dcc)
{
switch (dcc)
{
case DayCountConvention.ThirtyToThreeSixty:
return(360 * (dateTwo.Year - dateOne.Year) + 30 * (dateTwo.Month - dateOne.Month) + dateTwo.Day -
dateOne.Day);
case DayCountConvention.ActToThreeSixty:
case DayCountConvention.ActToThreeSixtyFive:
case DayCountConvention.ActToAct:
case DayCountConvention.ActToThreeSixtyFivePointTwoFive:
return((dateTwo.Date - dateOne.Date).TotalDays.ToInt());
default:
throw new ArgumentException();
}
}
internal static double PresentValue(DateTime ValueDate, double SpreadOverLibor, TermStructure ts, InputData inputData, Dictionary <DateTime, DateTime> Holidays, bool FixedCashPayments)
{
double ret = 0;
// LastPaymentDate should be the date from which we wish to start accrueing interest.
// This is either the lastcoupon payment (for fixed cash payments) or the Startdate if that is later and not Fixed Cash Payments
// The curve passed in (Rates) would have either the lastcouponpayment or the startdate as the preceding point
DateTime lastPayDate = DateTime.MinValue;
DayCountConvention dayC = ts.DayCount;
foreach (TermPoint point in ts.Points)
{
lastPayDate = point.PointDate;
if (point.PointDate >= ValueDate)
{
break;
}
}
for (int p = 1; p < ts.PointCount; p++)
{
DateTime nextPaymentDate = ts.Points[p].PointDate;
DateTime nextPayDate = ts.Points[p].PayDate;
int daysToDiscount = DaysBetween(ValueDate, nextPayDate, dayC);
if (daysToDiscount > 0)
{
double fixingRate = ts.Points[p].Rate;
double discountFactor = GetDiscountFactor(daysToDiscount, inputData.Rates, dayC);
int daysToAccrue = DaysBetween(lastPayDate, nextPaymentDate, dayC);
double paymentValue = AccruedForDaysInPeriod(ts.Points[p - 1].PointDate, ts.Points[p].PointDate, ts, fixingRate + SpreadOverLibor, FixedCashPayments);
ret += paymentValue * discountFactor;
}
lastPayDate = nextPayDate;
}
return(ret);
}
internal static int DaysInYear(DayCountConvention dayCount)
{
int ret = 0;
switch (dayCount)
{
case DayCountConvention.e30_360:
case DayCountConvention.e30E_360:
case DayCountConvention.e30E1_360:
case DayCountConvention.eActual_360:
ret = 360;
break;
case DayCountConvention.eActual_365:
case DayCountConvention.eActual_Actual:
case DayCountConvention.eActualNL_365:
ret = 365;
break;
}
return(ret);
}
private static double GetDayCountConventionDenominator(DateTime dateOne, DateTime dateTwo,
DayCountConvention dcc)
{
switch (dcc)
{
case DayCountConvention.ActToThreeSixty:
case DayCountConvention.ThirtyToThreeSixty:
return(360);
case DayCountConvention.ActToThreeSixtyFive:
return(365);
case DayCountConvention.ActToThreeSixtyFivePointTwoFive:
return(365.25);
case DayCountConvention.ActToAct:
return((dateTwo.Date - dateOne.Date).TotalDays);
default:
throw new ArgumentException();
}
}
/// <summary>
/// Function: Number of years between this business day and a given business day.
/// </summary>
/// <param name="dayCount">Number of business days away.
/// </param>
public double YearsBetween(BusinessDay day, DayCountConvention dayCount)
{
double t = -1;
if (dayCount == DayCountConvention.Act360)
{
return(YearsBetween(day, dayCount, 360.0));
}
else if (dayCount == DayCountConvention.Act365)
{
return(YearsBetween(day, dayCount, 365.0));
}
else if (dayCount == DayCountConvention.Thirty360)
{
return(YearsBetween(day, dayCount, 360.0));
}
else if (dayCount == DayCountConvention.Thirty365)
{
return(YearsBetween(day, dayCount, 365.0));
}
return(t);
}
/// <summary>
/// Function: Number of years between this business day and a given business day where day count convention has custom base.
/// </summary>
/// <param name="dayCount">Number of business days away.
/// </param>
/// <param name="baseCount">custom divisor in calculations of day count convention. Usually 252, 260, 360 or 365.
/// </param>
public double YearsBetween(BusinessDay day, DayCountConvention dayCount, double baseCount)
{
DateTime d1 = (this.DateTime < day.DateTime ? this.DateTime : day.DateTime);
DateTime d2 = (d1 == this.DateTime ? day.DateTime : this.DateTime);
double t = -1;
if (dayCount == DayCountConvention.Act360)
{
t = (d2.Date - d1.Date).TotalDays / baseCount;
}
else if (dayCount == DayCountConvention.Act365)
{
t = (d2.Date - d1.Date).TotalDays / baseCount;
}
else if (dayCount == DayCountConvention.Thirty360)
{
t = (Math.Max(0, 30 - d1.Day) + Math.Min(30, d2.Day) + 360 * (d2.Year - d1.Year) + 30 * (d2.Month - d1.Month - 1)) / baseCount;
}
else if (dayCount == DayCountConvention.Thirty365)
{
t = (Math.Max(0, 30 - d1.Day) + Math.Min(30, d2.Day) + 360 * (d2.Year - d1.Year) + 30 * (d2.Month - d1.Month - 1)) / baseCount;
}
else if (dayCount == DayCountConvention.Actual)
{
t = (d2.Date - d1.Date).TotalDays / baseCount;
}
else if (dayCount == DayCountConvention.Actual)
{
t = this.BusinessDaysBetween(day) / baseCount;
}
return(t);
}
public void AddCashFlow(double rate, InterestRateTenorType frequencyType, int frequency, InterestRateTenorType maturityType, int maturity, DayCountConvention dayCount)
{
// Console.WriteLine("Add Cashflow:" + rate + " " + frequencyType + " " + frequency + " " + maturityType + " " + maturity + " " + dayCount);
DateTime expiryDate = new DateTime();
switch (maturityType)
{
case InterestRateTenorType.Daily:
expiryDate = _startDate.AddActualDays(maturity, TimeSeries.DateSearchType.Next).DateTime;
break;
case InterestRateTenorType.Weekly:
expiryDate = _startDate.AddActualDays(maturity * 7, TimeSeries.DateSearchType.Next).DateTime;
break;
case InterestRateTenorType.Monthly:
expiryDate = _startDate.AddMonths(maturity, TimeSeries.DateSearchType.Next).DateTime;
break;
case InterestRateTenorType.Yearly:
expiryDate = _startDate.AddYears(maturity, TimeSeries.DateSearchType.Next).DateTime;
break;
default:
break;
}
CashFlowRate cf = new CashFlowRate(frequencyType, frequency, maturityType, maturity, dayCount, rate);
if (!_cashFlows.ContainsKey(expiryDate))
{
_cashFlows.Add(expiryDate, cf);
}
}
public InterestRateSwap CreateInterestRateSwap(InterestRate instrument, int floatFrequency, InterestRateTenorType floatFrequencyType, DayCountConvention floatDayCount, int fixedFrequency, InterestRateTenorType fixedFrequencyType, DayCountConvention fixedDayCount, int effective)
{
lock (objLock)
{
if (instrument.InstrumentType != InstrumentType.InterestRateSwap)
{
throw new Exception("Instrument is not an Interest Rate Swap");
}
string searchString = null;// "Name LIKE '" + name + "'";
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(_interestRateSwapTableName, targetString, searchString);
DataRowCollection rows = table.Rows;
var lrows = from lrow in new LINQList <DataRow>(rows)
where (int)lrow["ID"] == instrument.ID
select lrow;
if (lrows.Count() == 0)
{
DataRow r = table.NewRow();
r["ID"] = instrument.ID;
r["FloatFrequency"] = floatFrequency;
r["FloatFrequencyType"] = (int)floatFrequencyType;
r["FloatDayCountConvention"] = (int)floatDayCount;
r["FixedFrequency"] = fixedFrequency;
r["FixedFrequencyType"] = (int)fixedFrequencyType;
r["FixedDayCountConvention"] = (int)fixedDayCount;
r["Effective"] = effective;
rows.Add(r);
Database.DB["Quant"].UpdateDataTable(table);
return(FindInterestRateSwap(instrument));
}
throw new Exception("InterestRateSwap Already Exists");
}
}
/// <summary>
/// Interest = Principal x Coupon x DayCountFactor
/// </summary>
public static double DayCountFactor(DayCountConvention dayCountConvention, DateTime date1, DateTime date2, DateTime date3, PaymentFrequency paymentFrequency)
{
switch(dayCountConvention)
{
case DayCountConvention.ActActUS:
return (date2 - date1).Days / ((double)paymentFrequency * (date3 - date1).Days);
default:
throw new Exception(string.Format(@"No DayCountFactor method for DayCountConvention = {0}", dayCountConvention));
}
}
public static InterestRateSwap CreateInterestRateSwap(InterestRate instrument, int floatFrequency, InterestRateTenorType floatFrequencyType, DayCountConvention floatDayCount, int fixedFrequency, InterestRateTenorType fixedFrequencyType, DayCountConvention fixedDayCount, int effective)
{
return(Factory.CreateInterestRateSwap(instrument, floatFrequency, floatFrequencyType, floatDayCount, fixedFrequency, fixedFrequencyType, fixedDayCount, effective));
}
public static Deposit CreateDeposit(InterestRate instrument, DayCountConvention dayCount)
{
return(Factory.CreateDeposit(instrument, dayCount));
}
private void _addCashFlow(CashFlowRate cashFlow)
{
// Console.WriteLine("Add Cashflow:" + cashFlow.Rate + " " + cashFlow.MaturityType + " " + cashFlow.Maturity + " " + cashFlow.FrequencyType + " " + cashFlow.Frequency + " " + cashFlow.DayCount);
double rate = cashFlow.Rate;
InterestRateTenorType frequencyType = cashFlow.FrequencyType;
int frequency = cashFlow.Frequency;
InterestRateTenorType maturityType = cashFlow.MaturityType;
int maturity = cashFlow.Maturity;
DayCountConvention dayCount = cashFlow.DayCount;
BusinessDay expiryDate = null;
switch (maturityType)
{
case InterestRateTenorType.Daily:
expiryDate = _startDate.AddActualDays(maturity, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddActualDays(maturity, BusinessDaySearchType.Next);
break;
case InterestRateTenorType.Weekly:
expiryDate = _startDate.AddActualDays(maturity * 7, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddActualDays(maturity * 7, BusinessDaySearchType.Next);
break;
case InterestRateTenorType.Monthly:
expiryDate = _startDate.AddMonths(maturity, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddMonths(maturity, BusinessDaySearchType.Next);
break;
case InterestRateTenorType.Yearly:
expiryDate = _startDate.AddYears(maturity, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddYears(maturity, BusinessDaySearchType.Next);
break;
default:
break;
}
BusinessDay runningDate = _startDate;
if (frequencyType == maturityType && frequency == maturity)
{
double t = expiryDate.YearsBetween(_startDate, dayCount);
double pv = 1 / (1 + rate * t);
t = expiryDate.YearsBetween(_startDate, DayCountConvention.Act365);
_zeroRates.TryAdd(t, -Math.Log(pv) / t);
}
else
{
int counter = 1;
double pvs = 0;
double PV = 0;
double t = 0;
bool flag = true;
BusinessDay previousDate = _startDate;
while (flag)
{
previousDate = runningDate;
if (frequencyType == InterestRateTenorType.Daily)
{
runningDate = runningDate.AddBusinessDays(frequency * counter);
}
else if (frequencyType == InterestRateTenorType.Weekly)
{
runningDate = _startDate.AddActualDays(7 * frequency * counter, TimeSeries.DateSearchType.Next);
}
//runningDate = _startDate.AddActualDays(7 * frequency * counter, BusinessDaySearchType.Next);
else if (frequencyType == InterestRateTenorType.Monthly)
{
runningDate = _startDate.AddMonths(frequency * counter, TimeSeries.DateSearchType.Next);
}
//runningDate = _startDate.AddMonths(frequency * counter, BusinessDaySearchType.Next);
else if (frequencyType == InterestRateTenorType.Yearly)
{
runningDate = _startDate.AddYears(frequency * counter, TimeSeries.DateSearchType.Next);
}
//runningDate = _startDate.AddYears(frequency * counter, BusinessDaySearchType.Next);
flag = (runningDate.DateTime < expiryDate.DateTime);
if (flag)
{
counter++;
t = runningDate.YearsBetween(previousDate, dayCount);
pvs += rate * t * PresentValue(runningDate.YearsBetween(_startDate, DayCountConvention.Act365));
t = expiryDate.YearsBetween(runningDate, dayCount);
PV = (1 - pvs) / (1 + rate * t);
}
}
t = expiryDate.YearsBetween(_startDate, DayCountConvention.Act365);
double zeroRate = -Math.Log(PV) / t;
_zeroRates.TryAdd(t, zeroRate);
}
}
internal static TermStructure GetTermStructure(DateTime Maturity, DateTime StartDate, DateTime FirstCouponDate, double CouponRate,
DayCountConvention dayCount, NextWorkingDayConvention nextDay, int Freq, Dictionary <DateTime, DateTime> Holidays,
bool FixedCashPayments)
{
TermStructure ts = CalcCurveFromMaturity(Maturity, StartDate, CouponRate, nextDay, Freq, Holidays, false);
ts.DayCount = dayCount;
// Calc daycount depending on accrual rule
int yearDays = DaysInYear(dayCount);
int point;
TermPoint tp;
TermPoint ltp;
for (point = 1; point < ts.PointCount; point++)
{
tp = ts.Points[point];
ltp = ts.Points[point - 1];
tp.Term = DaysBetween(ltp.PointDate, tp.PointDate, dayCount);
if (FixedCashPayments)
{
int lastYear = (int)tp.PointDate.Subtract(tp.PointDate.AddYears(-1)).TotalDays;
if (tp.Term <= yearDays || lastYear == -366)
{
tp.EffectiveRate = tp.Rate / Freq * yearDays / tp.Term;
}
else
{
tp.EffectiveRate = tp.Rate;
}
}
else
{
tp.EffectiveRate = tp.Rate;
}
}
point = 0;
while (point > -1 && ts.PointCount > 1)
{
tp = ts.Points[point];
if (tp.PointDate < StartDate)
{
tp.PointDate = StartDate;
tp = ts.Points[point + 1];
tp.Term = DaysBetween(StartDate, tp.PointDate, dayCount);
}
else if (tp.PointDate > StartDate && tp.PointDate < FirstCouponDate && point != 0)
{
ts.Points.Remove(tp);
if (point < ts.PointCount && point > 0)
{
tp = ts.Points[point];
ltp = ts.Points[point - 1];
tp.Term = DaysBetween(ltp.PointDate, tp.PointDate, dayCount);
}
point--;
}
else if (tp.PointDate >= FirstCouponDate)
{
point = -2; // get out
}
point++;
}
int totalTerm = 0;
for (point = 1; point < ts.PointCount; point++)
{
tp = ts.Points[point];
ltp = ts.Points[point - 1];
// BUT for actual / actual and in a leap year some more calculations need to be done.
// e.g. Period 2 jan 96 to 1 jan 97 = (365/366 + 1/365) NOT including the last day but including the first day
if (dayCount == DayCountConvention.eActual_Actual && FixedCashPayments == false &&
ltp.PointDate.Year != tp.PointDate.Year)
{
tp.YearFraction =
ltp.PointDate.Subtract(DateTime.Parse("1 Jan " + ltp.PointDate.AddYears(1).Year)).TotalDays
/
DateTime.Parse("1 Jan " + ltp.PointDate.AddYears(1).Year).Subtract(DateTime.Parse("1 Jan " + ltp.PointDate.Year)).TotalDays
+
tp.PointDate.Subtract(DateTime.Parse("1 Jan " + tp.PointDate.Year)).TotalDays
/
DateTime.Parse("1 Jan " + tp.PointDate.AddYears(1).Year).Subtract(DateTime.Parse("1 Jan " + tp.PointDate.Year)).TotalDays;
}
else
{
if (tp.Rate > 0 && FixedCashPayments)
{
tp.YearFraction = tp.EffectiveRate * tp.Term / yearDays / tp.Rate;
}
else
{
tp.YearFraction = (double)tp.Term / (double)yearDays;
}
}
tp.Amount = tp.Rate * tp.YearFraction;
// Reset daycounts to be cummulative
totalTerm += tp.Term;
tp.Term = totalTerm;
}
return(ts);
}
public Deposit(InterestRate rate, DayCountConvention dayCountConvention)
: base(rate, rate.Maturity, rate.MaturityType)
{
this._dayCountConvention = dayCountConvention;
}
/// <summary>
/// Constructor for act/n and 30/n types of day counters.
/// </summary>
/// <param name="name"></param>
/// <param name="countConvention"></param>
/// <param name="basis"></param>
protected DayCounterBase(String name, DayCountConvention countConvention, int basis)
{
_name = name;
DayCountConvention = countConvention;
Basis = basis;
}