public AffineDivCurveUtils(DividendQuote[] dividends,
DiscountCurve discountCurve,
ITimeMeasure time)
{
Contract.Requires(EnumerableUtils.IsSorted(dividends.Select(div => div.Date)));
if (dividends.Length > 0)
{
double[] divDates = dividends.Map(div => time[div.Date]);
double[] spotYieldGrowths = dividends.Scan(1.0, (prev, div) => prev * (1.0 - div.Yield));
var spotYieldGrowth = new StepFunction(divDates, spotYieldGrowths, 1.0);
assetGrowth = t => spotYieldGrowth.Eval(t) / discountCurve.Zc(t);
double[] discountedCashs = dividends.Map(div => div.Cash / assetGrowth(time[div.Date]));
double[] cashBpvs = discountedCashs.Scan(0.0, (prev, c) => prev + c);
cashDivBpv = new StepFunction(divDates, cashBpvs, 0.0);
cashBpvIntegral = cashDivBpv.Integral(0.0);
double[] squareTimeWeightedCashs = discountedCashs.ZipWith(divDates, (c, t) => c * t * t);
squareTimeWeightedCash = new StepFunction(divDates, squareTimeWeightedCashs, 0.0);
}
else
{
assetGrowth = t => 1.0 / discountCurve.Zc(t);
cashDivBpv = new StepFunction(new[] { 0.0 }, new[] { 0.0 }, double.NaN);
cashBpvIntegral = RrFunctions.Zero;
squareTimeWeightedCash = new StepFunction(new[] { 0.0 }, new[] { 0.0 }, double.NaN);
}
}
public override double Eval(double x)
{
int leftIndex;
var spline = stepSplines.Eval(x, out leftIndex);
var h = x - pillars[Math.Max(0, leftIndex)];
return(spline.Eval(h));
}
private static RationalFraction BasedExtrapol(StepFunction <RationalFraction> stepSplines, double firstPillar)
{
var extrapol = stepSplines.Eval(double.NegativeInfinity);
var basedNum = extrapol.Num.TaylorDev(firstPillar - stepSplines.Pillars.First());
var basedDenom = extrapol.Denom.TaylorDev(firstPillar - stepSplines.Pillars.First());
return(basedNum / basedDenom);
}
public void TestEval()
{
var abs = new[] { 0.0, 0.5, 0.99, 2.5 };
var vals = new[] { 5.0, 5.4, 3.1, 1.0 };
const double leftVal = 0.0;
var stepFunc = new StepFunction(abs, vals, leftVal);
foreach (var i in Enumerable.Range(0, abs.Length))
{
Assert.AreEqual(stepFunc.Eval(abs[i]), vals[i]);
if (i < abs.Length - 1)
{
var midPoint = 0.5 * (abs[i] + abs[i + 1]);
Assert.AreEqual(stepFunc.Eval(midPoint), vals[i]);
var nextPointMinus = abs[i] + (1.0 - 5.0 * DoubleUtils.MachineEpsilon) * (abs[i + 1] - abs[i]);
Assert.AreEqual(stepFunc.Eval(nextPointMinus), vals[i]);
}
}
Assert.AreEqual(stepFunc.Eval(abs[0] - 0.00000000001), leftVal);
Assert.AreEqual(stepFunc.Eval(double.NegativeInfinity), leftVal);
Assert.AreEqual(stepFunc.Eval(abs[abs.Length - 1] + 0.00000000001), vals[abs.Length - 1]);
Assert.AreEqual(stepFunc.Eval(double.PositiveInfinity), vals[abs.Length - 1]);
}
public void TestMult()
{
var pillars1 = new[] { 0.0, 1.0, 2.0 };
var vals1 = new[] { 0.007, 0.004, 0.0065 };
const double left1 = 2.0;
var step1 = new StepFunction(pillars1, vals1, left1);
var pillars2 = new[] { -0.8, 0.2, 1.0, 1.5, 2.0, 3.55 };
var vals2 = new[] { 0.005, 0.003, -0.1, 0.0, -0.08, 10.0 };
const double left2 = -1.89;
var step2 = new StepFunction(pillars2, vals2, left2);
var prod = step1 * step2;
Assert.IsTrue(prod is StepFunction);
var allPillars = pillars1.Union(pillars2).OrderBy(p => p).ToArray();
for (int i = 0; i < allPillars.Length; i++)
{
double x = allPillars[i];
var val1 = step1.Eval(x);
var val2 = step2.Eval(x);
var prodVal = prod.Eval(x);
Assert.IsTrue(DoubleUtils.MachineEquality(prodVal, val1 * val2));
}
Assert.IsTrue(DoubleUtils.MachineEquality(prod.Eval(double.NegativeInfinity),
step1.Eval(double.NegativeInfinity) * step2.Eval(double.NegativeInfinity)));
var rand = new Random(123);
double a = allPillars.Max() - allPillars.Min();
double b = allPillars.Min();
for (int i = 0; i < 1000; i++)
{
var x = rand.NextDouble() * a * 3.0 + b - 0.1 * a;
var val1 = step1.Eval(x);
var val2 = step2.Eval(x);
var prodVal = prod.Eval(x);
Assert.IsTrue(DoubleUtils.MachineEquality(prodVal, val1 * val2));
}
}
private static RationalFraction BasedSpline(StepFunction <RationalFraction> stepSplines, double basePoint)
{
int stepIndex;
var spline = stepSplines.Eval(basePoint, out stepIndex);
var splineBasePoint = stepSplines.Pillars[Math.Max(0, stepIndex)];
var basedNum = spline.Num.TaylorDev(basePoint - splineBasePoint);
var basedDenom = spline.Denom.TaylorDev(basePoint - splineBasePoint);
return(basedNum / basedDenom);
}
public double CashBpvTimeWeightedAverage(double t)
{
//throw new NotImplementedException("todo");
return(cashDivBpv.Eval(t) - squareTimeWeightedCash.Eval(t) / (t * t));
}
public double CashDivBpv(double t)
{
return(cashDivBpv.Eval(t));
}
