// need a based date?
//
///<summary>
///</summary>
///<param name="discountCurve"></param>
///<param name="baseDate"></param>
///<param name="frequency"></param>
///<param name="dayCounter"></param>
///<returns></returns>
///<exception cref="System.Exception"></exception>
public static TermCurve ToZeroCurve(TermCurve discountCurve, DateTime baseDate,
CompoundingFrequencyEnum frequency, IDayCounter dayCounter)
{
TermCurve result = TermCurve.Create(new List <TermPoint>());
foreach (TermPoint point in discountCurve.point)
{
DateTime pointDate = XsdClassesFieldResolver.TimeDimensionGetDate(point.term);
double zeroRateDouble;
if (baseDate != pointDate)
{
double time = dayCounter.YearFraction(baseDate, pointDate);
zeroRateDouble = RateAnalytics.DiscountFactorToZeroRate((double)point.mid, time, frequency);
}
else
{
// set after the loop
zeroRateDouble = 0;
}
TermPoint zeroPoint = TermPointFactory.Create(Convert.ToDecimal(zeroRateDouble), pointDate);
zeroPoint.id = point.id;
result.Add(zeroPoint);
}
if (result.point[0].mid == 0)
{
result.point[0].mid = result.point[1].mid;
}
return(result);
}
/// <summary>
/// Converts from the zero rate to a terminal wealth.
/// </summary>
/// <param name="rate"></param>
/// <param name="yearFraction"></param>
/// <param name="compoundingFrequency"></param>
/// <returns></returns>
public static decimal TerminalWealthFromZeroRate(decimal rate, decimal yearFraction,
CompoundingFrequencyEnum compoundingFrequency)
{
double compoundingPeriod = GetCompoundingPeriod(compoundingFrequency);
decimal result;
if (compoundingPeriod == 0)
{
result = (decimal)Math.Exp(Convert.ToDouble(-rate * yearFraction));
}
else
{
decimal df;
if ((double)yearFraction > compoundingPeriod)
{
df = (decimal)Math.Pow(1 + compoundingPeriod * (double)rate, (double)yearFraction);
}
else
{
df = 1 + yearFraction * rate;
}
result = 1 / df;
}
return(result);
}
/// <summary>
/// Converts a discount factor to a compounding zero rate.
/// </summary>
///<param name="discountFactor"></param>
///<param name="yearFraction"></param>
///<param name="compoundingFrequencyEnum"></param>
///<returns></returns>
public static double DiscountFactorToZeroRate(double discountFactor, double yearFraction,
CompoundingFrequencyEnum compoundingFrequencyEnum)
{
double compoundingPeriod = GetCompoundingPeriod(compoundingFrequencyEnum);
return(DiscountFactorToZeroRate(discountFactor, yearFraction, compoundingPeriod));
}
///<summary>
///</summary>
///<param name="zeroRate"></param>
///<param name="yearFraction"></param>
///<param name="compoundingFrequencyEnum"></param>
///<returns></returns>
///<exception cref="NotImplementedException"></exception>
public static double ZeroRateToDiscountFactor(double zeroRate, double yearFraction,
CompoundingFrequencyEnum compoundingFrequencyEnum)
{
double compoundingPeriod = GetCompoundingPeriod(compoundingFrequencyEnum);
return(ZeroRateToDiscountFactor(zeroRate, yearFraction, compoundingPeriod));
}
///<summary>
///</summary>
///<param name="zeroRate"></param>
///<param name="yearFraction"></param>
///<param name="compoundingFrequencyEnum"></param>
///<returns></returns>
///<exception cref="NotImplementedException"></exception>
public static double ZeroRateToDiscountFactor(double zeroRate, double yearFraction,
CompoundingFrequencyEnum compoundingFrequencyEnum)
{
double compoundingPeriod = GetCompoundingPeriod(compoundingFrequencyEnum);
return(Highlander.Numerics.Rates.RateAnalytics.ZeroRateToDiscountFactor(zeroRate, yearFraction, compoundingPeriod));
}
/// <summary>
/// Gets the dividend discount factor.
/// </summary>
public static decimal GetDiscountFactor(decimal years, decimal rate, CompoundingFrequencyEnum cf)
{
double years0 = Convert.ToDouble(years);
double rate0 = Convert.ToDouble(rate);
double df = RateAnalytics.ZeroRateToDiscountFactor(rate0, years0, cf);
decimal df0 = Convert.ToDecimal(df);
return(df0);
}
/// <summary>
///
/// </summary>
/// <param name="frequency"></param>
/// <returns></returns>
public static CompoundingFrequency Create(CompoundingFrequencyEnum frequency)
{
var result
= new CompoundingFrequency
{
Value = CompoundingFrequencyScheme.GetEnumString(frequency)
};
return(result);
}
private static double GetCompoundingPeriod(CompoundingFrequencyEnum compoundingFrequencyEnum)
{
double frequency;
switch (compoundingFrequencyEnum)
{
case CompoundingFrequencyEnum.Continuous:
frequency = 0;
break;
case CompoundingFrequencyEnum.Daily:
frequency = 1 / 365d;
break;
case CompoundingFrequencyEnum.Weekly:
frequency = 1 / 52d;
break;
case CompoundingFrequencyEnum.Monthly:
frequency = 1 / 12d;
break;
case CompoundingFrequencyEnum.Quarterly:
frequency = 0.25;
break;
case CompoundingFrequencyEnum.SemiAnnual:
frequency = 0.5;
break;
case CompoundingFrequencyEnum.Annual:
frequency = 1;
break;
default:
throw new ArgumentOutOfRangeException(nameof(compoundingFrequencyEnum), "CompoundingFrequency is of an invalid type " + compoundingFrequencyEnum);
}
return(frequency);
}
///<summary>
///</summary>
///<param name="baseDate"></param>
///<param name="frequency"></param>
///<param name="dayCountFraction"></param>
///<returns></returns>
///<exception cref="NotImplementedException"></exception>
public static decimal PeriodFractionFromCompoundingFrequency(DateTime baseDate, CompoundingFrequencyEnum frequency, DayCountFraction dayCountFraction)
{
switch (frequency)
{
case CompoundingFrequencyEnum.Continuous:
return(0.0m);
case CompoundingFrequencyEnum.Daily:
IDayCounter dc = DayCounterHelper.Parse(dayCountFraction.Value);
return((decimal)dc.YearFraction(baseDate, baseDate.AddDays(1.0d)));
case CompoundingFrequencyEnum.Weekly:
return((decimal)1 / 52);
case CompoundingFrequencyEnum.Monthly:
return((decimal)1 / 12);
case CompoundingFrequencyEnum.Quarterly:
return((decimal)1 / 4);
case CompoundingFrequencyEnum.SemiAnnual:
return((decimal)1 / 2);
case CompoundingFrequencyEnum.Annual:
return(1.0m);
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Anns the yield.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="targetDate">The target date.</param>
/// <param name="divCurve">The div curve.</param>
/// <param name="ratetimes">The rate times.</param>
/// <param name="rateamts">The rate amounts.</param>
/// <param name="im">the im?</param>
/// <param name="cf">The cf?</param>
/// <returns></returns>
public static double GetPVDivs(double yearFraction1, double yearFraction2, int[] divdays, double[] divamts, int[] ratedays, double[] rateamts, string im, CompoundingFrequencyEnum cf, int daybasis)
{
DiscreteCurve divCurve = CreateCurve(divdays, divamts, daybasis);
DiscreteCurve rc = CreateCurve(ratedays, rateamts, daybasis);
List <IPoint> points = divCurve.GetPointList();
double sum = 0;
var rateCurve = new InterpolatedCurve(rc, InterpolationFactory.Create(im), false);
foreach (IPoint pt in points)
{
decimal t = Convert.ToDecimal(pt.GetX());
decimal rate = Convert.ToDecimal(rateCurve.Value(pt));
double df = Convert.ToDouble(GetDiscountFactor(t, rate, cf));
if ((pt.GetX() <= yearFraction2) & (pt.GetX() > yearFraction1))
{
sum += pt.FunctionValue * df;
}
}
return(sum);
}
/// <summary>
/// Anns the yield.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="targetDate">The target date.</param>
/// <param name="divCurve">The div curve.</param>
/// <param name="ratetimes">The rate times.</param>
/// <param name="rateamts">The rate amounts.</param>
/// <param name="im">the im?</param>
/// <param name="cf">The cf?</param>
/// <returns></returns>
public static double GetPVDivs(DateTime baseDate, DateTime targetDate, DiscreteCurve divCurve, double[] ratetimes, double[] rateamts, string im, CompoundingFrequencyEnum cf)
{
List <IPoint> points = divCurve.GetPointList();
double sum = 0;
var rateCurve = new InterpolatedCurve(new DiscreteCurve(ratetimes, rateamts), InterpolationFactory.Create(im), false);
int t0 = (targetDate - baseDate).Days;
double maturity = t0 / 365.0;
foreach (IPoint pt in points)
{
decimal t = Convert.ToDecimal(pt.GetX());
decimal rate = Convert.ToDecimal(rateCurve.Value(pt));
double df = Convert.ToDouble(GetDiscountFactor(t, rate, cf));
if ((pt.GetX() <= maturity) & (pt.GetX() > 0))
{
sum += pt.FunctionValue * df;
}
}
return(sum);
}
