public BeatSequence Build(RealInterval span)
{
beats.Sort(TimedEvent <Beat> .Comparer);
var finalSpan = span ?? new RealInterval(beats.First().Time, beats.Last().Time);
return(new BeatSequence(beats.ToArray(), finalSpan));
}
public RegularGridAffineInterpol(RealInterval support, int size, double[] f)
{
Contract.Requires(f.Length == size);
this.f = f;
inf = support.Inf;
step = support.Length / (f.Length - 1);
df = EnumerableUtils.For(0, f.Length - 1, i => f[i + 1] - f[i]);
}
private static RealInterval GridSupport(double gridQuantile, VolatilitySurface volSurface, double t)
{
var impliedVar = volSurface.VarianceInterpoler.TimeSlice(t) / t;
Func <double, double> vol = k => Math.Sqrt(impliedVar.Eval(Math.Log(k)));
var mInf = Math.Log(SmileLawUtils.ComputeQuantile(1.0, t, vol, gridQuantile));
var mSup = Math.Log(SmileLawUtils.ComputeQuantile(1.0, t, vol, 1.0 - gridQuantile));
return(RealInterval.Compact(mInf, mSup));
}
private static RegularGridAffineInterpol LocalVolDiscretization(Func <double, double> localVol, VolatilitySurface volSurface, double t)
{
const double gridQuantile = 1.0e-6;
const int gridSize = 250;
RealInterval gridSupport = GridSupport(gridQuantile, volSurface, t);
double[] localVolGridValues = GridUtils.RegularGrid(gridSupport, gridSize).Map(localVol);
var gridLocalVol = new RegularGridAffineInterpol(gridSupport, gridSize, localVolGridValues);
return(gridLocalVol);
}
public void RealIntervalCoverage()
{
var a = new RealInterval(7, 42);
var b = new RealInterval(40, 50);
var c = new RealInterval(200, 100); // negative
var e = RealInterval.Empty;
var empty = RealInterval.Coverage(new RealInterval[] { });
var single = RealInterval.Coverage(new RealInterval[] { a });
var ab = RealInterval.Coverage(new RealInterval[] { a, b });
var ba = RealInterval.Coverage(new RealInterval[] { b, a });
var ac = RealInterval.Coverage(new RealInterval[] { a, c });
var ca = RealInterval.Coverage(new RealInterval[] { c, a });
var ae = RealInterval.Coverage(new RealInterval[] { a, e });
var ea = RealInterval.Coverage(new RealInterval[] { e, a });
var bc = RealInterval.Coverage(new RealInterval[] { b, c });
var cb = RealInterval.Coverage(new RealInterval[] { c, b });
var be = RealInterval.Coverage(new RealInterval[] { b, e });
var eb = RealInterval.Coverage(new RealInterval[] { e, b });
var ce = RealInterval.Coverage(new RealInterval[] { c, e });
var ec = RealInterval.Coverage(new RealInterval[] { e, c });
Assert.IsTrue(c.IsNegative);
Assert.AreEqual(0, empty.Right);
Assert.AreEqual(0, empty.Left);
Assert.AreEqual(a.Left, single.Left);
Assert.AreEqual(a.Right, single.Right);
Assert.AreEqual(ab.Left, a.Left);
Assert.AreEqual(ab.Right, b.Right);
Assert.AreEqual(ba.Left, a.Left);
Assert.AreEqual(ba.Right, b.Right);
Assert.AreEqual(ac.Left, a.Left);
Assert.AreEqual(ac.Right, c.Left); // c is negative
Assert.AreEqual(ae.Left, a.Left);
Assert.AreEqual(ae.Right, a.Right);
Assert.AreEqual(ea.Left, a.Left);
Assert.AreEqual(ea.Right, a.Right);
Assert.AreEqual(ca.Left, a.Left);
Assert.AreEqual(ca.Right, c.Left); // c is negative
Assert.AreEqual(bc.Left, b.Left);
Assert.AreEqual(bc.Right, c.Left); // c is negative
Assert.AreEqual(cb.Left, b.Left);
Assert.AreEqual(cb.Right, c.Left); // c is negative
Assert.AreEqual(be.Left, b.Left);
Assert.AreEqual(be.Right, b.Right);
Assert.AreEqual(eb.Left, b.Left);
Assert.AreEqual(eb.Right, b.Right);
Assert.AreEqual(ce.Left, c.Right); // c is negative
Assert.AreEqual(ec.Right, c.Left); // c is negative
Assert.IsTrue(RealInterval.Coverage(new RealInterval[] { }).IsEmpty); // empty sequence -> empty interval
Assert.IsTrue(RealInterval.Coverage(new RealInterval[] { e }).IsEmpty); // sequence of only empty intervals -> empty interval
}
public BsEqtySimulatorStepDatas(RealInterval step, double[] dates, DiscreteLocalDividend[] dividends, double[] discounts,
double[] vols, double[] varDrifts)
{
Contract.Requires(dividends.Length == vols.Length);
Contract.Requires(dates.All(step.Contain));
Contract.Requires(EnumerableUtils.IsSorted(dividends.Map(div => div.Date)));
Step = step;
Dates = dates;
Dividends = dividends;
Discounts = discounts;
Vols = vols;
VarDrifts = varDrifts;
}
private LocalVolSimulatorStepDatas StepSimulDatas(DateTime start, DateTime end, LocalVolatilityModel model, DiscountCurve assetDiscount, DateTime horizon)
{
DateTime[] dates;
bool[] isDivDate;
DiscreteLocalDividend[] dividends;
StepSchedule(start, end, model, out dates, out isDivDate, out dividends);
var horizonDiscount = assetDiscount.Zc(horizon);
var discounts = dividends.Map(div => horizonDiscount / assetDiscount.Zc(div.Date));
var localVols = EnumerableUtils.For(0, dates.Length,
i => StepLocalVol(i > 0 ? dates[i - 1] : start, dates[i], model));
var step = RealInterval.Compact(model.Time[start], model.Time[end]);
return(new LocalVolSimulatorStepDatas(step, dates.Map(d => model.Time[d]), isDivDate, dividends, discounts, localVols));
}
public void LeftBoundedIntInterval()
{
var interval = RealInterval.LeftBounded(7.0);
Assert.IsTrue(interval.LeftEndpoint.Bounded);
Assert.IsTrue(interval.LeftEndpoint.Inclusive);
Assert.AreEqual(7.0, interval.Left);
Assert.IsFalse(interval.RightEndpoint.Bounded);
Assert.IsFalse(interval.RightEndpoint.Inclusive);
Assert.AreEqual(double.MaxValue, interval.Right);
Assert.AreEqual(double.MaxValue, interval.Span);
Assert.IsFalse(interval.IsClosed);
Assert.IsFalse(interval.IsDegenerate);
Assert.IsFalse(interval.IsFinite);
Assert.IsTrue(interval.IsHalfBounded);
Assert.IsFalse(interval.IsOpen);
}
public void BoundedRealInterval()
{
var interval = new RealInterval(7.0, true, 42.0, false);
Assert.IsTrue(interval.LeftEndpoint.Bounded);
Assert.IsTrue(interval.LeftEndpoint.Inclusive);
Assert.AreEqual(7.0, interval.Left);
Assert.IsTrue(interval.RightEndpoint.Bounded);
Assert.IsFalse(interval.RightEndpoint.Inclusive);
Assert.AreEqual(42.0, interval.Right);
Assert.AreEqual(42.0 - 7.0, interval.Span);
Assert.IsFalse(interval.IsClosed);
Assert.IsFalse(interval.IsDegenerate);
Assert.IsTrue(interval.IsFinite);
Assert.IsFalse(interval.IsHalfBounded);
Assert.IsFalse(interval.IsOpen);
}
public LocalVolSimulatorStepDatas(RealInterval step, double[] dates,
bool[] isDivDates, DiscreteLocalDividend[] dividends,
double[] discounts, Func <double, double>[] localVols)
{
Contract.Requires(dates.Length == isDivDates.Length);
Contract.Requires(isDivDates.Length == dividends.Length);
Contract.Requires(dividends.Length == discounts.Length);
Contract.Requires(discounts.Length == localVols.Length);
Contract.Requires(dates.All(step.Contain));
Contract.Requires(EnumerableUtils.IsSorted(dividends.Map(div => div.Date)));
Step = step;
Dates = dates;
IsDivDates = isDivDates;
Dividends = dividends;
Discounts = discounts;
LocalVols = localVols;
}
public void IsValueInLimitsTest()
{
// [1; +inf[
RealInterval interval = new RealInterval()
{
LowerLimit = 1, UpperLimit = Double.PositiveInfinity, IntervalType = IntervalTypes.HalfInclusive
};
Assert.IsTrue(interval.IsValueInLimits(1));
Assert.IsTrue(interval.IsValueInLimits(Double.MaxValue));
Assert.IsFalse(interval.IsValueInLimits(0));
Assert.IsFalse(interval.IsValueInLimits(0.5));
Assert.IsFalse(interval.IsValueInLimits(Double.NegativeInfinity));
Assert.IsFalse(interval.IsValueInLimits(Double.PositiveInfinity));
// ]1; +inf[
interval = new RealInterval()
{
LowerLimit = 1, UpperLimit = Double.PositiveInfinity, IntervalType = IntervalTypes.Exclusive
};
Assert.IsTrue(interval.IsValueInLimits(Double.MaxValue));
Assert.IsFalse(interval.IsValueInLimits(0));
Assert.IsFalse(interval.IsValueInLimits(0.5));
Assert.IsFalse(interval.IsValueInLimits(1));
Assert.IsFalse(interval.IsValueInLimits(Double.PositiveInfinity));
Assert.IsFalse(interval.IsValueInLimits(Double.NegativeInfinity));
// ]0;1]
interval = new RealInterval()
{
LowerLimit = 0, UpperLimit = 1, IntervalType = IntervalTypes.HalfExclusive
};
Assert.IsTrue(interval.IsValueInLimits(1));
Assert.IsFalse(interval.IsValueInLimits(Double.MaxValue));
Assert.IsFalse(interval.IsValueInLimits(-0.1));
Assert.IsFalse(interval.IsValueInLimits(0));
Assert.IsTrue(interval.IsValueInLimits(0.5));
Assert.IsFalse(interval.IsValueInLimits(Double.PositiveInfinity));
Assert.IsFalse(interval.IsValueInLimits(Double.NegativeInfinity));
}
private BsEqtySimulatorStepDatas StepSimulDatas(DateTime start, DateTime end, BlackScholesModel model, DiscountCurve assetDiscount, DateTime horizon)
{
DiscreteLocalDividend[] stepDividends = model.Dividends
.Where(div => start < div.Date && div.Date <= end)
.OrderBy(div => div.Date)
.ToArray();
//If step end date is not a div date, we insert a fictious zero dividend
if (!(stepDividends.Any() && end.Equals(stepDividends.Last().Date)))
{
stepDividends = stepDividends.Union(new[] { DiscreteLocalDividend.ZeroDiv(end) }).ToArray();
}
var variance = (model.Sigma * model.Sigma).Integral(0.0);
var stepVols = new double[stepDividends.Length];
var stepVarDrifts = new double[stepDividends.Length];
for (int i = 0; i < stepDividends.Length; i++)
{
var subStepStart = i > 0 ? stepDividends[i - 1].Date : start;
var subStepEnd = stepDividends[i].Date;
var subStep = RealInterval.Compact(model.Time[subStepStart], model.Time[subStepEnd]);
var stepVariance = variance.Eval(subStep.Sup) - variance.Eval(subStep.Inf);
var stepVarDrift = -0.5 * stepVariance;
stepVols[i] = Math.Sqrt(stepVariance / subStep.Length);
stepVarDrifts[i] = stepVarDrift;
}
var horizonDiscount = assetDiscount.Zc(horizon);
var discounts = stepDividends.Map(div => horizonDiscount / assetDiscount.Zc(div.Date));
var dates = model.Time[stepDividends.Map(div => div.Date)];
var step = RealInterval.Compact(model.Time[start], model.Time[end]);
return(new BsEqtySimulatorStepDatas(step, dates, stepDividends, discounts, stepVols, stepVarDrifts));
}
private BeatSequence(TimedEvent <Beat>[] beats, RealInterval span)
{
this.beats = beats;
this.span = span;
}
